|  | @@ -16,17 +16,15 @@ export type Scalars = {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type Block = Node & {
 | 
	
		
			
				|  |  |    id: Scalars['ID'],
 | 
	
		
			
				|  |  | -  sequence: Scalars['Int'],
 | 
	
		
			
				|  |  |    title: Scalars['String'],
 | 
	
		
			
				|  |  |    description?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    videos: Array<Scalars['String']>,
 | 
	
		
			
				|  |  |    pictures: Array<Scalars['String']>,
 | 
	
		
			
				|  |  |    duration?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    format: Format,
 | 
	
		
			
				|  |  |    rest?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    tracks?: Maybe<Array<Track>>,
 | 
	
		
			
				|  |  | -  blocks?: Maybe<Array<Block>>,
 | 
	
		
			
				|  |  | +  blocks?: Maybe<Array<BlockInstance>>,
 | 
	
		
			
				|  |  |    exercises?: Maybe<Array<ExerciseInstance>>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -43,8 +41,8 @@ export type BlockTracksArgs = {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type BlockBlocksArgs = {
 | 
	
		
			
				|  |  | -  where?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  orderBy?: Maybe<BlockOrderByInput>,
 | 
	
		
			
				|  |  | +  where?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  orderBy?: Maybe<BlockInstanceOrderByInput>,
 | 
	
		
			
				|  |  |    skip?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    after?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    before?: Maybe<Scalars['String']>,
 | 
	
	
		
			
				|  | @@ -63,48 +61,183 @@ export type BlockExercisesArgs = {
 | 
	
		
			
				|  |  |    last?: Maybe<Scalars['Int']>
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -export type BlockCreateInput = {
 | 
	
		
			
				|  |  | +export type BlockCreateOneWithoutBlocksInput = {
 | 
	
		
			
				|  |  | +  create?: Maybe<BlockCreateWithoutBlocksInput>,
 | 
	
		
			
				|  |  | +  connect?: Maybe<BlockWhereUniqueInput>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockCreatepicturesInput = {
 | 
	
		
			
				|  |  | +  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockCreatevideosInput = {
 | 
	
		
			
				|  |  | +  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockCreateWithoutBlocksInput = {
 | 
	
		
			
				|  |  |    id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | -  sequence: Scalars['Int'],
 | 
	
		
			
				|  |  |    title: Scalars['String'],
 | 
	
		
			
				|  |  |    description?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    duration?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    rest?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    videos?: Maybe<BlockCreatevideosInput>,
 | 
	
		
			
				|  |  |    pictures?: Maybe<BlockCreatepicturesInput>,
 | 
	
		
			
				|  |  |    format: FormatCreateOneInput,
 | 
	
		
			
				|  |  |    tracks?: Maybe<TrackCreateManyInput>,
 | 
	
		
			
				|  |  | -  blocks?: Maybe<BlockCreateManyInput>,
 | 
	
		
			
				|  |  |    exercises?: Maybe<ExerciseInstanceCreateManyInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -export type BlockCreateManyInput = {
 | 
	
		
			
				|  |  | -  create?: Maybe<Array<BlockCreateInput>>,
 | 
	
		
			
				|  |  | -  connect?: Maybe<Array<BlockWhereUniqueInput>>,
 | 
	
		
			
				|  |  | +export type BlockInstance = Node & {
 | 
	
		
			
				|  |  | +  id: Scalars['ID'],
 | 
	
		
			
				|  |  | +  block: Block,
 | 
	
		
			
				|  |  | +  order: Scalars['Int'],
 | 
	
		
			
				|  |  | +  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -export type BlockCreatepicturesInput = {
 | 
	
		
			
				|  |  | -  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +export type BlockInstanceCreateInput = {
 | 
	
		
			
				|  |  | +  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  order: Scalars['Int'],
 | 
	
		
			
				|  |  | +  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  block: BlockCreateOneWithoutBlocksInput,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -export type BlockCreatevideosInput = {
 | 
	
		
			
				|  |  | -  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +export type BlockInstanceCreateManyInput = {
 | 
	
		
			
				|  |  | +  create?: Maybe<Array<BlockInstanceCreateInput>>,
 | 
	
		
			
				|  |  | +  connect?: Maybe<Array<BlockInstanceWhereUniqueInput>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockInstanceCreateManyWithoutBlockInput = {
 | 
	
		
			
				|  |  | +  create?: Maybe<Array<BlockInstanceCreateWithoutBlockInput>>,
 | 
	
		
			
				|  |  | +  connect?: Maybe<Array<BlockInstanceWhereUniqueInput>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockInstanceCreateWithoutBlockInput = {
 | 
	
		
			
				|  |  | +  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  order: Scalars['Int'],
 | 
	
		
			
				|  |  | +  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export enum BlockInstanceOrderByInput {
 | 
	
		
			
				|  |  | +  IdAsc = 'id_ASC',
 | 
	
		
			
				|  |  | +  IdDesc = 'id_DESC',
 | 
	
		
			
				|  |  | +  OrderAsc = 'order_ASC',
 | 
	
		
			
				|  |  | +  OrderDesc = 'order_DESC',
 | 
	
		
			
				|  |  | +  RoundsAsc = 'rounds_ASC',
 | 
	
		
			
				|  |  | +  RoundsDesc = 'rounds_DESC',
 | 
	
		
			
				|  |  | +  VariationAsc = 'variation_ASC',
 | 
	
		
			
				|  |  | +  VariationDesc = 'variation_DESC'
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockInstanceWhereInput = {
 | 
	
		
			
				|  |  | +  /** Logical AND on all given filters. */
 | 
	
		
			
				|  |  | +  AND?: Maybe<Array<BlockInstanceWhereInput>>,
 | 
	
		
			
				|  |  | +  /** Logical OR on all given filters. */
 | 
	
		
			
				|  |  | +  OR?: Maybe<Array<BlockInstanceWhereInput>>,
 | 
	
		
			
				|  |  | +  /** Logical NOT on all given filters combined by AND. */
 | 
	
		
			
				|  |  | +  NOT?: Maybe<Array<BlockInstanceWhereInput>>,
 | 
	
		
			
				|  |  | +  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  id_not?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  id_in?: Maybe<Array<Scalars['ID']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  id_not_in?: Maybe<Array<Scalars['ID']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  id_lt?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  id_lte?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  id_gt?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  id_gte?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values containing the given string. */
 | 
	
		
			
				|  |  | +  id_contains?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values not containing the given string. */
 | 
	
		
			
				|  |  | +  id_not_contains?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values starting with the given string. */
 | 
	
		
			
				|  |  | +  id_starts_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values not starting with the given string. */
 | 
	
		
			
				|  |  | +  id_not_starts_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values ending with the given string. */
 | 
	
		
			
				|  |  | +  id_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  /** All values not ending with the given string. */
 | 
	
		
			
				|  |  | +  id_not_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  order?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  order_not?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  order_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  order_not_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  order_lt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  order_lte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  order_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  order_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  rounds_not?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  rounds_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  rounds_not_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  rounds_lt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  rounds_lte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  rounds_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  rounds_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  variation_not?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  variation_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  variation_not_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  variation_lt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  variation_lte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  variation_gt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  variation_gte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values containing the given string. */
 | 
	
		
			
				|  |  | +  variation_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not containing the given string. */
 | 
	
		
			
				|  |  | +  variation_not_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values starting with the given string. */
 | 
	
		
			
				|  |  | +  variation_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not starting with the given string. */
 | 
	
		
			
				|  |  | +  variation_not_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values ending with the given string. */
 | 
	
		
			
				|  |  | +  variation_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not ending with the given string. */
 | 
	
		
			
				|  |  | +  variation_not_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  block?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockInstanceWhereUniqueInput = {
 | 
	
		
			
				|  |  | +  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export enum BlockOrderByInput {
 | 
	
		
			
				|  |  |    IdAsc = 'id_ASC',
 | 
	
		
			
				|  |  |    IdDesc = 'id_DESC',
 | 
	
		
			
				|  |  | -  SequenceAsc = 'sequence_ASC',
 | 
	
		
			
				|  |  | -  SequenceDesc = 'sequence_DESC',
 | 
	
		
			
				|  |  |    TitleAsc = 'title_ASC',
 | 
	
		
			
				|  |  |    TitleDesc = 'title_DESC',
 | 
	
		
			
				|  |  |    DescriptionAsc = 'description_ASC',
 | 
	
		
			
				|  |  |    DescriptionDesc = 'description_DESC',
 | 
	
		
			
				|  |  |    DurationAsc = 'duration_ASC',
 | 
	
		
			
				|  |  |    DurationDesc = 'duration_DESC',
 | 
	
		
			
				|  |  | -  RoundsAsc = 'rounds_ASC',
 | 
	
		
			
				|  |  | -  RoundsDesc = 'rounds_DESC',
 | 
	
		
			
				|  |  |    RestAsc = 'rest_ASC',
 | 
	
		
			
				|  |  |    RestDesc = 'rest_DESC'
 | 
	
		
			
				|  |  |  }
 | 
	
	
		
			
				|  | @@ -143,21 +276,6 @@ export type BlockWhereInput = {
 | 
	
		
			
				|  |  |    id_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  |    /** All values not ending with the given string. */
 | 
	
		
			
				|  |  |    id_not_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | -  sequence?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | -  sequence_not?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | -  sequence_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | -  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | -  sequence_not_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | -  /** All values less than the given value. */
 | 
	
		
			
				|  |  | -  sequence_lt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | -  sequence_lte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | -  sequence_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | -  sequence_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    title?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  |    title_not?: Maybe<Scalars['String']>,
 | 
	
	
		
			
				|  | @@ -227,21 +345,6 @@ export type BlockWhereInput = {
 | 
	
		
			
				|  |  |    duration_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  |    duration_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  rounds?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | -  rounds_not?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | -  rounds_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | -  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | -  rounds_not_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | -  /** All values less than the given value. */
 | 
	
		
			
				|  |  | -  rounds_lt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | -  rounds_lte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | -  rounds_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | -  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | -  rounds_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    rest?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  |    rest_not?: Maybe<Scalars['Int']>,
 | 
	
	
		
			
				|  | @@ -261,9 +364,9 @@ export type BlockWhereInput = {
 | 
	
		
			
				|  |  |    tracks_every?: Maybe<TrackWhereInput>,
 | 
	
		
			
				|  |  |    tracks_some?: Maybe<TrackWhereInput>,
 | 
	
		
			
				|  |  |    tracks_none?: Maybe<TrackWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_every?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_some?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_none?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | +  blocks_every?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  blocks_some?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  blocks_none?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  |    exercises_every?: Maybe<ExerciseInstanceWhereInput>,
 | 
	
		
			
				|  |  |    exercises_some?: Maybe<ExerciseInstanceWhereInput>,
 | 
	
		
			
				|  |  |    exercises_none?: Maybe<ExerciseInstanceWhereInput>,
 | 
	
	
		
			
				|  | @@ -501,7 +604,8 @@ export type Exercise = Node & {
 | 
	
		
			
				|  |  |    id: Scalars['ID'],
 | 
	
		
			
				|  |  |    name: Scalars['String'],
 | 
	
		
			
				|  |  |    description: Scalars['String'],
 | 
	
		
			
				|  |  | -  video: Scalars['String'],
 | 
	
		
			
				|  |  | +  videos: Array<Scalars['String']>,
 | 
	
		
			
				|  |  | +  pictures: Array<Scalars['String']>,
 | 
	
		
			
				|  |  |    targets: Array<Scalars['String']>,
 | 
	
		
			
				|  |  |    baseExercise: Array<Scalars['String']>,
 | 
	
		
			
				|  |  |  };
 | 
	
	
		
			
				|  | @@ -514,7 +618,8 @@ export type ExerciseCreateInput = {
 | 
	
		
			
				|  |  |    id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  |    name: Scalars['String'],
 | 
	
		
			
				|  |  |    description: Scalars['String'],
 | 
	
		
			
				|  |  | -  video: Scalars['String'],
 | 
	
		
			
				|  |  | +  videos?: Maybe<ExerciseCreatevideosInput>,
 | 
	
		
			
				|  |  | +  pictures?: Maybe<ExerciseCreatepicturesInput>,
 | 
	
		
			
				|  |  |    targets?: Maybe<ExerciseCreatetargetsInput>,
 | 
	
		
			
				|  |  |    baseExercise?: Maybe<ExerciseCreatebaseExerciseInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
	
		
			
				|  | @@ -524,19 +629,31 @@ export type ExerciseCreateOneInput = {
 | 
	
		
			
				|  |  |    connect?: Maybe<ExerciseWhereUniqueInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export type ExerciseCreatepicturesInput = {
 | 
	
		
			
				|  |  | +  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type ExerciseCreatetargetsInput = {
 | 
	
		
			
				|  |  |    set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export type ExerciseCreatevideosInput = {
 | 
	
		
			
				|  |  | +  set?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type ExerciseInstance = Node & {
 | 
	
		
			
				|  |  |    id: Scalars['ID'],
 | 
	
		
			
				|  |  |    exercise: Exercise,
 | 
	
		
			
				|  |  | +  order: Scalars['Int'],
 | 
	
		
			
				|  |  |    repetitions?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type ExerciseInstanceCreateInput = {
 | 
	
		
			
				|  |  |    id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  order: Scalars['Int'],
 | 
	
		
			
				|  |  |    repetitions?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    exercise: ExerciseCreateOneInput,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -548,8 +665,12 @@ export type ExerciseInstanceCreateManyInput = {
 | 
	
		
			
				|  |  |  export enum ExerciseInstanceOrderByInput {
 | 
	
		
			
				|  |  |    IdAsc = 'id_ASC',
 | 
	
		
			
				|  |  |    IdDesc = 'id_DESC',
 | 
	
		
			
				|  |  | +  OrderAsc = 'order_ASC',
 | 
	
		
			
				|  |  | +  OrderDesc = 'order_DESC',
 | 
	
		
			
				|  |  |    RepetitionsAsc = 'repetitions_ASC',
 | 
	
		
			
				|  |  | -  RepetitionsDesc = 'repetitions_DESC'
 | 
	
		
			
				|  |  | +  RepetitionsDesc = 'repetitions_DESC',
 | 
	
		
			
				|  |  | +  VariationAsc = 'variation_ASC',
 | 
	
		
			
				|  |  | +  VariationDesc = 'variation_DESC'
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type ExerciseInstanceWhereInput = {
 | 
	
	
		
			
				|  | @@ -586,6 +707,21 @@ export type ExerciseInstanceWhereInput = {
 | 
	
		
			
				|  |  |    id_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  |    /** All values not ending with the given string. */
 | 
	
		
			
				|  |  |    id_not_ends_with?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  order?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  order_not?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  order_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  order_not_in?: Maybe<Array<Scalars['Int']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  order_lt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  order_lte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  order_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  order_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    repetitions?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  |    repetitions_not?: Maybe<Scalars['Int']>,
 | 
	
	
		
			
				|  | @@ -601,6 +737,33 @@ export type ExerciseInstanceWhereInput = {
 | 
	
		
			
				|  |  |    repetitions_gt?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  |    repetitions_gte?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | +  variation_not?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | +  variation_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | +  variation_not_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  /** All values less than the given value. */
 | 
	
		
			
				|  |  | +  variation_lt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | +  variation_lte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | +  variation_gt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | +  variation_gte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values containing the given string. */
 | 
	
		
			
				|  |  | +  variation_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not containing the given string. */
 | 
	
		
			
				|  |  | +  variation_not_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values starting with the given string. */
 | 
	
		
			
				|  |  | +  variation_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not starting with the given string. */
 | 
	
		
			
				|  |  | +  variation_not_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values ending with the given string. */
 | 
	
		
			
				|  |  | +  variation_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  /** All values not ending with the given string. */
 | 
	
		
			
				|  |  | +  variation_not_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    exercise?: Maybe<ExerciseWhereInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -608,6 +771,15 @@ export type ExerciseInstanceWhereUniqueInput = {
 | 
	
		
			
				|  |  |    id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export enum ExerciseOrderByInput {
 | 
	
		
			
				|  |  | +  IdAsc = 'id_ASC',
 | 
	
		
			
				|  |  | +  IdDesc = 'id_DESC',
 | 
	
		
			
				|  |  | +  NameAsc = 'name_ASC',
 | 
	
		
			
				|  |  | +  NameDesc = 'name_DESC',
 | 
	
		
			
				|  |  | +  DescriptionAsc = 'description_ASC',
 | 
	
		
			
				|  |  | +  DescriptionDesc = 'description_DESC'
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type ExerciseWhereInput = {
 | 
	
		
			
				|  |  |    /** Logical AND on all given filters. */
 | 
	
		
			
				|  |  |    AND?: Maybe<Array<ExerciseWhereInput>>,
 | 
	
	
		
			
				|  | @@ -696,33 +868,6 @@ export type ExerciseWhereInput = {
 | 
	
		
			
				|  |  |    description_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    /** All values not ending with the given string. */
 | 
	
		
			
				|  |  |    description_not_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  video?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values that are not equal to given value. */
 | 
	
		
			
				|  |  | -  video_not?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values that are contained in given list. */
 | 
	
		
			
				|  |  | -  video_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | -  /** All values that are not contained in given list. */
 | 
	
		
			
				|  |  | -  video_not_in?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | -  /** All values less than the given value. */
 | 
	
		
			
				|  |  | -  video_lt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values less than or equal the given value. */
 | 
	
		
			
				|  |  | -  video_lte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values greater than the given value. */
 | 
	
		
			
				|  |  | -  video_gt?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values greater than or equal the given value. */
 | 
	
		
			
				|  |  | -  video_gte?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values containing the given string. */
 | 
	
		
			
				|  |  | -  video_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values not containing the given string. */
 | 
	
		
			
				|  |  | -  video_not_contains?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values starting with the given string. */
 | 
	
		
			
				|  |  | -  video_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values not starting with the given string. */
 | 
	
		
			
				|  |  | -  video_not_starts_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values ending with the given string. */
 | 
	
		
			
				|  |  | -  video_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  /** All values not ending with the given string. */
 | 
	
		
			
				|  |  | -  video_not_ends_with?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type ExerciseWhereUniqueInput = {
 | 
	
	
		
			
				|  | @@ -885,10 +1030,10 @@ export type MutationCreateTrainingArgs = {
 | 
	
		
			
				|  |  |    title: Scalars['String'],
 | 
	
		
			
				|  |  |    type: TrainingTypeCreateOneInput,
 | 
	
		
			
				|  |  |    trainingDate: Scalars['DateTime'],
 | 
	
		
			
				|  |  | -  location: Scalars['String'],
 | 
	
		
			
				|  |  | -  attendance: Scalars['Int'],
 | 
	
		
			
				|  |  | +  location?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  attendance?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    published: Scalars['Boolean'],
 | 
	
		
			
				|  |  | -  blocks?: Maybe<BlockCreateManyInput>
 | 
	
		
			
				|  |  | +  blocks?: Maybe<BlockInstanceCreateManyInput>
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -899,14 +1044,16 @@ export type MutationCreateTrainingTypeArgs = {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type MutationCreateBlockArgs = {
 | 
	
		
			
				|  |  | -  sequence: Scalars['Int'],
 | 
	
		
			
				|  |  |    title: Scalars['String'],
 | 
	
		
			
				|  |  | -  duration: Scalars['Int'],
 | 
	
		
			
				|  |  | -  variation?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | -  format?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | -  tracks: Array<Maybe<Scalars['ID']>>,
 | 
	
		
			
				|  |  | -  exercises: Array<Maybe<Scalars['ID']>>,
 | 
	
		
			
				|  |  | -  description: Scalars['String']
 | 
	
		
			
				|  |  | +  description?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  videos?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  pictures?: Maybe<Array<Scalars['String']>>,
 | 
	
		
			
				|  |  | +  duration?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  format: FormatCreateOneInput,
 | 
	
		
			
				|  |  | +  rest?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  tracks?: Maybe<TrackCreateManyInput>,
 | 
	
		
			
				|  |  | +  blocks?: Maybe<BlockInstanceCreateManyWithoutBlockInput>,
 | 
	
		
			
				|  |  | +  exercises?: Maybe<ExerciseInstanceCreateManyInput>
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -951,14 +1098,24 @@ export enum Permission {
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type Query = {
 | 
	
		
			
				|  |  | +  currentUser: User,
 | 
	
		
			
				|  |  | +  user?: Maybe<User>,
 | 
	
		
			
				|  |  |    users: Array<User>,
 | 
	
		
			
				|  |  |    training?: Maybe<Training>,
 | 
	
		
			
				|  |  |    trainings: Array<Training>,
 | 
	
		
			
				|  |  |    trainingType?: Maybe<TrainingType>,
 | 
	
		
			
				|  |  |    trainingTypes: Array<TrainingType>,
 | 
	
		
			
				|  |  | +  block?: Maybe<Block>,
 | 
	
		
			
				|  |  |    blocks: Array<Block>,
 | 
	
		
			
				|  |  | +  format?: Maybe<Format>,
 | 
	
		
			
				|  |  |    formats: Array<Format>,
 | 
	
		
			
				|  |  | -  currentUser: User,
 | 
	
		
			
				|  |  | +  exercise?: Maybe<Exercise>,
 | 
	
		
			
				|  |  | +  exercises: Array<Exercise>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type QueryUserArgs = {
 | 
	
		
			
				|  |  | +  where: UserWhereUniqueInput
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -974,7 +1131,7 @@ export type QueryUsersArgs = {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type QueryTrainingArgs = {
 | 
	
		
			
				|  |  | -  where: TrainingWhereUniqueInput
 | 
	
		
			
				|  |  | +  id: Scalars['ID']
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -1005,6 +1162,11 @@ export type QueryTrainingTypesArgs = {
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export type QueryBlockArgs = {
 | 
	
		
			
				|  |  | +  where: BlockWhereUniqueInput
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type QueryBlocksArgs = {
 | 
	
		
			
				|  |  |    where?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  |    orderBy?: Maybe<BlockOrderByInput>,
 | 
	
	
		
			
				|  | @@ -1016,6 +1178,11 @@ export type QueryBlocksArgs = {
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export type QueryFormatArgs = {
 | 
	
		
			
				|  |  | +  where: FormatWhereUniqueInput
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type QueryFormatsArgs = {
 | 
	
		
			
				|  |  |    where?: Maybe<FormatWhereInput>,
 | 
	
		
			
				|  |  |    orderBy?: Maybe<FormatOrderByInput>,
 | 
	
	
		
			
				|  | @@ -1026,6 +1193,22 @@ export type QueryFormatsArgs = {
 | 
	
		
			
				|  |  |    last?: Maybe<Scalars['Int']>
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type QueryExerciseArgs = {
 | 
	
		
			
				|  |  | +  where: ExerciseWhereUniqueInput
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type QueryExercisesArgs = {
 | 
	
		
			
				|  |  | +  where?: Maybe<ExerciseWhereInput>,
 | 
	
		
			
				|  |  | +  orderBy?: Maybe<ExerciseOrderByInput>,
 | 
	
		
			
				|  |  | +  skip?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  after?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  before?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +  first?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  | +  last?: Maybe<Scalars['Int']>
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type Rating = Node & {
 | 
	
		
			
				|  |  |    id: Scalars['ID'],
 | 
	
		
			
				|  |  |    user: User,
 | 
	
	
		
			
				|  | @@ -1466,7 +1649,7 @@ export type Training = Node & {
 | 
	
		
			
				|  |  |    attendance?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    ratings?: Maybe<Array<Rating>>,
 | 
	
		
			
				|  |  |    published: Scalars['Boolean'],
 | 
	
		
			
				|  |  | -  blocks?: Maybe<Array<Block>>,
 | 
	
		
			
				|  |  | +  blocks?: Maybe<Array<BlockInstance>>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -1493,8 +1676,8 @@ export type TrainingRatingsArgs = {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type TrainingBlocksArgs = {
 | 
	
		
			
				|  |  | -  where?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  orderBy?: Maybe<BlockOrderByInput>,
 | 
	
		
			
				|  |  | +  where?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  orderBy?: Maybe<BlockInstanceOrderByInput>,
 | 
	
		
			
				|  |  |    skip?: Maybe<Scalars['Int']>,
 | 
	
		
			
				|  |  |    after?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  |    before?: Maybe<Scalars['String']>,
 | 
	
	
		
			
				|  | @@ -1783,13 +1966,9 @@ export type TrainingWhereInput = {
 | 
	
		
			
				|  |  |    ratings_every?: Maybe<RatingWhereInput>,
 | 
	
		
			
				|  |  |    ratings_some?: Maybe<RatingWhereInput>,
 | 
	
		
			
				|  |  |    ratings_none?: Maybe<RatingWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_every?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_some?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -  blocks_none?: Maybe<BlockWhereInput>,
 | 
	
		
			
				|  |  | -};
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -export type TrainingWhereUniqueInput = {
 | 
	
		
			
				|  |  | -  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  blocks_every?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  blocks_some?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  | +  blocks_none?: Maybe<BlockInstanceWhereInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  export type User = Node & {
 | 
	
	
		
			
				|  | @@ -2066,6 +2245,21 @@ export type UserWhereInput = {
 | 
	
		
			
				|  |  |    ratings_none?: Maybe<RatingWhereInput>,
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export type UserWhereUniqueInput = {
 | 
	
		
			
				|  |  | +  id?: Maybe<Scalars['ID']>,
 | 
	
		
			
				|  |  | +  email?: Maybe<Scalars['String']>,
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type TrainingQueryVariables = {
 | 
	
		
			
				|  |  | +  id: Scalars['ID']
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type TrainingQuery = { training: Maybe<(
 | 
	
		
			
				|  |  | +    Pick<Training, 'id' | 'title' | 'location' | 'trainingDate' | 'attendance' | 'published'>
 | 
	
		
			
				|  |  | +    & { type: Pick<TrainingType, 'id'> }
 | 
	
		
			
				|  |  | +  )> };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  export type TrainingsQueryVariables = {};
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -2098,7 +2292,7 @@ export type CreateTrainingMutationVariables = {
 | 
	
		
			
				|  |  |    location: Scalars['String'],
 | 
	
		
			
				|  |  |    attendance: Scalars['Int'],
 | 
	
		
			
				|  |  |    published: Scalars['Boolean'],
 | 
	
		
			
				|  |  | -  blocks?: Maybe<BlockCreateManyInput>
 | 
	
		
			
				|  |  | +  blocks?: Maybe<BlockInstanceCreateManyInput>
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -2183,6 +2377,47 @@ export type UserUpdateMutationVariables = {
 | 
	
		
			
				|  |  |  export type UserUpdateMutation = { updateUser: Maybe<Pick<User, 'id' | 'name' | 'email' | 'permissions' | 'interests'>> };
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +export const TrainingDocument = gql`
 | 
	
		
			
				|  |  | +    query training($id: ID!) {
 | 
	
		
			
				|  |  | +  training(id: $id) {
 | 
	
		
			
				|  |  | +    id
 | 
	
		
			
				|  |  | +    title
 | 
	
		
			
				|  |  | +    type {
 | 
	
		
			
				|  |  | +      id
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +    location
 | 
	
		
			
				|  |  | +    trainingDate
 | 
	
		
			
				|  |  | +    attendance
 | 
	
		
			
				|  |  | +    published
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +    `;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * __useTrainingQuery__
 | 
	
		
			
				|  |  | + *
 | 
	
		
			
				|  |  | + * To run a query within a React component, call `useTrainingQuery` and pass it any options that fit your needs.
 | 
	
		
			
				|  |  | + * When your component renders, `useTrainingQuery` returns an object from Apollo Client that contains loading, error, and data properties 
 | 
	
		
			
				|  |  | + * you can use to render your UI.
 | 
	
		
			
				|  |  | + *
 | 
	
		
			
				|  |  | + * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 | 
	
		
			
				|  |  | + *
 | 
	
		
			
				|  |  | + * @example
 | 
	
		
			
				|  |  | + * const { data, loading, error } = useTrainingQuery({
 | 
	
		
			
				|  |  | + *   variables: {
 | 
	
		
			
				|  |  | + *      id: // value for 'id'
 | 
	
		
			
				|  |  | + *   },
 | 
	
		
			
				|  |  | + * });
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +export function useTrainingQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<TrainingQuery, TrainingQueryVariables>) {
 | 
	
		
			
				|  |  | +        return ApolloReactHooks.useQuery<TrainingQuery, TrainingQueryVariables>(TrainingDocument, baseOptions);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +export function useTrainingLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<TrainingQuery, TrainingQueryVariables>) {
 | 
	
		
			
				|  |  | +          return ApolloReactHooks.useLazyQuery<TrainingQuery, TrainingQueryVariables>(TrainingDocument, baseOptions);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +export type TrainingQueryHookResult = ReturnType<typeof useTrainingQuery>;
 | 
	
		
			
				|  |  | +export type TrainingLazyQueryHookResult = ReturnType<typeof useTrainingLazyQuery>;
 | 
	
		
			
				|  |  | +export type TrainingQueryResult = ApolloReactCommon.QueryResult<TrainingQuery, TrainingQueryVariables>;
 | 
	
		
			
				|  |  |  export const TrainingsDocument = gql`
 | 
	
		
			
				|  |  |      query trainings {
 | 
	
		
			
				|  |  |    trainings {
 | 
	
	
		
			
				|  | @@ -2329,7 +2564,7 @@ export type FormatsQueryHookResult = ReturnType<typeof useFormatsQuery>;
 | 
	
		
			
				|  |  |  export type FormatsLazyQueryHookResult = ReturnType<typeof useFormatsLazyQuery>;
 | 
	
		
			
				|  |  |  export type FormatsQueryResult = ApolloReactCommon.QueryResult<FormatsQuery, FormatsQueryVariables>;
 | 
	
		
			
				|  |  |  export const CreateTrainingDocument = gql`
 | 
	
		
			
				|  |  | -    mutation createTraining($title: String!, $type: TrainingTypeCreateOneInput!, $trainingDate: DateTime!, $location: String!, $attendance: Int!, $published: Boolean!, $blocks: BlockCreateManyInput) {
 | 
	
		
			
				|  |  | +    mutation createTraining($title: String!, $type: TrainingTypeCreateOneInput!, $trainingDate: DateTime!, $location: String!, $attendance: Int!, $published: Boolean!, $blocks: BlockInstanceCreateManyInput) {
 | 
	
		
			
				|  |  |    createTraining(title: $title, type: $type, trainingDate: $trainingDate, location: $location, attendance: $attendance, published: $published, blocks: $blocks) {
 | 
	
		
			
				|  |  |      id
 | 
	
		
			
				|  |  |    }
 |