u-fit/backend/database/generated/prisma-client/index.ts

// Code generated by Prisma (prisma@1.34.10). DO NOT EDIT.
// Please don't change this file manually but run `prisma generate` to update it.
// For more information, please read the docs: https://www.prisma.io/docs/prisma-client/

import { DocumentNode } from "graphql";
import {
  makePrismaClientClass,
  BaseClientOptions,
  Model
} from "prisma-client-lib";
import { typeDefs } from "./prisma-schema";

export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> &
  U[keyof U];

export type Maybe<T> = T | undefined | null;

export interface Exists {
  block: (where?: BlockWhereInput) => Promise<boolean>;
  blockInstance: (where?: BlockInstanceWhereInput) => Promise<boolean>;
  comment: (where?: CommentWhereInput) => Promise<boolean>;
  exercise: (where?: ExerciseWhereInput) => Promise<boolean>;
  exerciseInstance: (where?: ExerciseInstanceWhereInput) => Promise<boolean>;
  file: (where?: FileWhereInput) => Promise<boolean>;
  format: (where?: FormatWhereInput) => Promise<boolean>;
  link: (where?: LinkWhereInput) => Promise<boolean>;
  picture: (where?: PictureWhereInput) => Promise<boolean>;
  rating: (where?: RatingWhereInput) => Promise<boolean>;
  track: (where?: TrackWhereInput) => Promise<boolean>;
  training: (where?: TrainingWhereInput) => Promise<boolean>;
  trainingType: (where?: TrainingTypeWhereInput) => Promise<boolean>;
  user: (where?: UserWhereInput) => Promise<boolean>;
  video: (where?: VideoWhereInput) => Promise<boolean>;
}

export interface Node {}

export type FragmentableArray<T> = Promise<Array<T>> & Fragmentable;

export interface Fragmentable {
  $fragment<T>(fragment: string | DocumentNode): Promise<T>;
}

export interface Prisma {
  $exists: Exists;
  $graphql: <T = any>(
    query: string,
    variables?: { [key: string]: any }
  ) => Promise<T>;

  /**
   * Queries
   */

  block: (where: BlockWhereUniqueInput) => BlockNullablePromise;
  blocks: (args?: {
    where?: BlockWhereInput;
    orderBy?: BlockOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Block>;
  blocksConnection: (args?: {
    where?: BlockWhereInput;
    orderBy?: BlockOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => BlockConnectionPromise;
  blockInstance: (
    where: BlockInstanceWhereUniqueInput
  ) => BlockInstanceNullablePromise;
  blockInstances: (args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<BlockInstance>;
  blockInstancesConnection: (args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => BlockInstanceConnectionPromise;
  comment: (where: CommentWhereUniqueInput) => CommentNullablePromise;
  comments: (args?: {
    where?: CommentWhereInput;
    orderBy?: CommentOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Comment>;
  commentsConnection: (args?: {
    where?: CommentWhereInput;
    orderBy?: CommentOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => CommentConnectionPromise;
  exercise: (where: ExerciseWhereUniqueInput) => ExerciseNullablePromise;
  exercises: (args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Exercise>;
  exercisesConnection: (args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => ExerciseConnectionPromise;
  exerciseInstance: (
    where: ExerciseInstanceWhereUniqueInput
  ) => ExerciseInstanceNullablePromise;
  exerciseInstances: (args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<ExerciseInstance>;
  exerciseInstancesConnection: (args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => ExerciseInstanceConnectionPromise;
  file: (where: FileWhereUniqueInput) => FileNullablePromise;
  files: (args?: {
    where?: FileWhereInput;
    orderBy?: FileOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<File>;
  filesConnection: (args?: {
    where?: FileWhereInput;
    orderBy?: FileOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FileConnectionPromise;
  format: (where: FormatWhereUniqueInput) => FormatNullablePromise;
  formats: (args?: {
    where?: FormatWhereInput;
    orderBy?: FormatOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Format>;
  formatsConnection: (args?: {
    where?: FormatWhereInput;
    orderBy?: FormatOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FormatConnectionPromise;
  link: (where: LinkWhereUniqueInput) => LinkNullablePromise;
  links: (args?: {
    where?: LinkWhereInput;
    orderBy?: LinkOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Link>;
  linksConnection: (args?: {
    where?: LinkWhereInput;
    orderBy?: LinkOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => LinkConnectionPromise;
  picture: (where: PictureWhereUniqueInput) => PictureNullablePromise;
  pictures: (args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Picture>;
  picturesConnection: (args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => PictureConnectionPromise;
  rating: (where: RatingWhereUniqueInput) => RatingNullablePromise;
  ratings: (args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Rating>;
  ratingsConnection: (args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => RatingConnectionPromise;
  track: (where: TrackWhereUniqueInput) => TrackNullablePromise;
  tracks: (args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Track>;
  tracksConnection: (args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => TrackConnectionPromise;
  training: (where: TrainingWhereUniqueInput) => TrainingNullablePromise;
  trainings: (args?: {
    where?: TrainingWhereInput;
    orderBy?: TrainingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Training>;
  trainingsConnection: (args?: {
    where?: TrainingWhereInput;
    orderBy?: TrainingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => TrainingConnectionPromise;
  trainingType: (
    where: TrainingTypeWhereUniqueInput
  ) => TrainingTypeNullablePromise;
  trainingTypes: (args?: {
    where?: TrainingTypeWhereInput;
    orderBy?: TrainingTypeOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<TrainingType>;
  trainingTypesConnection: (args?: {
    where?: TrainingTypeWhereInput;
    orderBy?: TrainingTypeOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => TrainingTypeConnectionPromise;
  user: (where: UserWhereUniqueInput) => UserNullablePromise;
  users: (args?: {
    where?: UserWhereInput;
    orderBy?: UserOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<User>;
  usersConnection: (args?: {
    where?: UserWhereInput;
    orderBy?: UserOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => UserConnectionPromise;
  video: (where: VideoWhereUniqueInput) => VideoNullablePromise;
  videos: (args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<Video>;
  videosConnection: (args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => VideoConnectionPromise;
  node: (args: { id: ID_Output }) => Node;

  /**
   * Mutations
   */

  createBlock: (data: BlockCreateInput) => BlockPromise;
  updateBlock: (args: {
    data: BlockUpdateInput;
    where: BlockWhereUniqueInput;
  }) => BlockPromise;
  updateManyBlocks: (args: {
    data: BlockUpdateManyMutationInput;
    where?: BlockWhereInput;
  }) => BatchPayloadPromise;
  upsertBlock: (args: {
    where: BlockWhereUniqueInput;
    create: BlockCreateInput;
    update: BlockUpdateInput;
  }) => BlockPromise;
  deleteBlock: (where: BlockWhereUniqueInput) => BlockPromise;
  deleteManyBlocks: (where?: BlockWhereInput) => BatchPayloadPromise;
  createBlockInstance: (data: BlockInstanceCreateInput) => BlockInstancePromise;
  updateBlockInstance: (args: {
    data: BlockInstanceUpdateInput;
    where: BlockInstanceWhereUniqueInput;
  }) => BlockInstancePromise;
  updateManyBlockInstances: (args: {
    data: BlockInstanceUpdateManyMutationInput;
    where?: BlockInstanceWhereInput;
  }) => BatchPayloadPromise;
  upsertBlockInstance: (args: {
    where: BlockInstanceWhereUniqueInput;
    create: BlockInstanceCreateInput;
    update: BlockInstanceUpdateInput;
  }) => BlockInstancePromise;
  deleteBlockInstance: (
    where: BlockInstanceWhereUniqueInput
  ) => BlockInstancePromise;
  deleteManyBlockInstances: (
    where?: BlockInstanceWhereInput
  ) => BatchPayloadPromise;
  createComment: (data: CommentCreateInput) => CommentPromise;
  updateComment: (args: {
    data: CommentUpdateInput;
    where: CommentWhereUniqueInput;
  }) => CommentPromise;
  updateManyComments: (args: {
    data: CommentUpdateManyMutationInput;
    where?: CommentWhereInput;
  }) => BatchPayloadPromise;
  upsertComment: (args: {
    where: CommentWhereUniqueInput;
    create: CommentCreateInput;
    update: CommentUpdateInput;
  }) => CommentPromise;
  deleteComment: (where: CommentWhereUniqueInput) => CommentPromise;
  deleteManyComments: (where?: CommentWhereInput) => BatchPayloadPromise;
  createExercise: (data: ExerciseCreateInput) => ExercisePromise;
  updateExercise: (args: {
    data: ExerciseUpdateInput;
    where: ExerciseWhereUniqueInput;
  }) => ExercisePromise;
  updateManyExercises: (args: {
    data: ExerciseUpdateManyMutationInput;
    where?: ExerciseWhereInput;
  }) => BatchPayloadPromise;
  upsertExercise: (args: {
    where: ExerciseWhereUniqueInput;
    create: ExerciseCreateInput;
    update: ExerciseUpdateInput;
  }) => ExercisePromise;
  deleteExercise: (where: ExerciseWhereUniqueInput) => ExercisePromise;
  deleteManyExercises: (where?: ExerciseWhereInput) => BatchPayloadPromise;
  createExerciseInstance: (
    data: ExerciseInstanceCreateInput
  ) => ExerciseInstancePromise;
  updateExerciseInstance: (args: {
    data: ExerciseInstanceUpdateInput;
    where: ExerciseInstanceWhereUniqueInput;
  }) => ExerciseInstancePromise;
  updateManyExerciseInstances: (args: {
    data: ExerciseInstanceUpdateManyMutationInput;
    where?: ExerciseInstanceWhereInput;
  }) => BatchPayloadPromise;
  upsertExerciseInstance: (args: {
    where: ExerciseInstanceWhereUniqueInput;
    create: ExerciseInstanceCreateInput;
    update: ExerciseInstanceUpdateInput;
  }) => ExerciseInstancePromise;
  deleteExerciseInstance: (
    where: ExerciseInstanceWhereUniqueInput
  ) => ExerciseInstancePromise;
  deleteManyExerciseInstances: (
    where?: ExerciseInstanceWhereInput
  ) => BatchPayloadPromise;
  createFile: (data: FileCreateInput) => FilePromise;
  updateFile: (args: {
    data: FileUpdateInput;
    where: FileWhereUniqueInput;
  }) => FilePromise;
  updateManyFiles: (args: {
    data: FileUpdateManyMutationInput;
    where?: FileWhereInput;
  }) => BatchPayloadPromise;
  upsertFile: (args: {
    where: FileWhereUniqueInput;
    create: FileCreateInput;
    update: FileUpdateInput;
  }) => FilePromise;
  deleteFile: (where: FileWhereUniqueInput) => FilePromise;
  deleteManyFiles: (where?: FileWhereInput) => BatchPayloadPromise;
  createFormat: (data: FormatCreateInput) => FormatPromise;
  updateFormat: (args: {
    data: FormatUpdateInput;
    where: FormatWhereUniqueInput;
  }) => FormatPromise;
  updateManyFormats: (args: {
    data: FormatUpdateManyMutationInput;
    where?: FormatWhereInput;
  }) => BatchPayloadPromise;
  upsertFormat: (args: {
    where: FormatWhereUniqueInput;
    create: FormatCreateInput;
    update: FormatUpdateInput;
  }) => FormatPromise;
  deleteFormat: (where: FormatWhereUniqueInput) => FormatPromise;
  deleteManyFormats: (where?: FormatWhereInput) => BatchPayloadPromise;
  createLink: (data: LinkCreateInput) => LinkPromise;
  updateLink: (args: {
    data: LinkUpdateInput;
    where: LinkWhereUniqueInput;
  }) => LinkPromise;
  updateManyLinks: (args: {
    data: LinkUpdateManyMutationInput;
    where?: LinkWhereInput;
  }) => BatchPayloadPromise;
  upsertLink: (args: {
    where: LinkWhereUniqueInput;
    create: LinkCreateInput;
    update: LinkUpdateInput;
  }) => LinkPromise;
  deleteLink: (where: LinkWhereUniqueInput) => LinkPromise;
  deleteManyLinks: (where?: LinkWhereInput) => BatchPayloadPromise;
  createPicture: (data: PictureCreateInput) => PicturePromise;
  updatePicture: (args: {
    data: PictureUpdateInput;
    where: PictureWhereUniqueInput;
  }) => PicturePromise;
  updateManyPictures: (args: {
    data: PictureUpdateManyMutationInput;
    where?: PictureWhereInput;
  }) => BatchPayloadPromise;
  upsertPicture: (args: {
    where: PictureWhereUniqueInput;
    create: PictureCreateInput;
    update: PictureUpdateInput;
  }) => PicturePromise;
  deletePicture: (where: PictureWhereUniqueInput) => PicturePromise;
  deleteManyPictures: (where?: PictureWhereInput) => BatchPayloadPromise;
  createRating: (data: RatingCreateInput) => RatingPromise;
  updateRating: (args: {
    data: RatingUpdateInput;
    where: RatingWhereUniqueInput;
  }) => RatingPromise;
  updateManyRatings: (args: {
    data: RatingUpdateManyMutationInput;
    where?: RatingWhereInput;
  }) => BatchPayloadPromise;
  upsertRating: (args: {
    where: RatingWhereUniqueInput;
    create: RatingCreateInput;
    update: RatingUpdateInput;
  }) => RatingPromise;
  deleteRating: (where: RatingWhereUniqueInput) => RatingPromise;
  deleteManyRatings: (where?: RatingWhereInput) => BatchPayloadPromise;
  createTrack: (data: TrackCreateInput) => TrackPromise;
  updateTrack: (args: {
    data: TrackUpdateInput;
    where: TrackWhereUniqueInput;
  }) => TrackPromise;
  updateManyTracks: (args: {
    data: TrackUpdateManyMutationInput;
    where?: TrackWhereInput;
  }) => BatchPayloadPromise;
  upsertTrack: (args: {
    where: TrackWhereUniqueInput;
    create: TrackCreateInput;
    update: TrackUpdateInput;
  }) => TrackPromise;
  deleteTrack: (where: TrackWhereUniqueInput) => TrackPromise;
  deleteManyTracks: (where?: TrackWhereInput) => BatchPayloadPromise;
  createTraining: (data: TrainingCreateInput) => TrainingPromise;
  updateTraining: (args: {
    data: TrainingUpdateInput;
    where: TrainingWhereUniqueInput;
  }) => TrainingPromise;
  updateManyTrainings: (args: {
    data: TrainingUpdateManyMutationInput;
    where?: TrainingWhereInput;
  }) => BatchPayloadPromise;
  upsertTraining: (args: {
    where: TrainingWhereUniqueInput;
    create: TrainingCreateInput;
    update: TrainingUpdateInput;
  }) => TrainingPromise;
  deleteTraining: (where: TrainingWhereUniqueInput) => TrainingPromise;
  deleteManyTrainings: (where?: TrainingWhereInput) => BatchPayloadPromise;
  createTrainingType: (data: TrainingTypeCreateInput) => TrainingTypePromise;
  updateTrainingType: (args: {
    data: TrainingTypeUpdateInput;
    where: TrainingTypeWhereUniqueInput;
  }) => TrainingTypePromise;
  updateManyTrainingTypes: (args: {
    data: TrainingTypeUpdateManyMutationInput;
    where?: TrainingTypeWhereInput;
  }) => BatchPayloadPromise;
  upsertTrainingType: (args: {
    where: TrainingTypeWhereUniqueInput;
    create: TrainingTypeCreateInput;
    update: TrainingTypeUpdateInput;
  }) => TrainingTypePromise;
  deleteTrainingType: (
    where: TrainingTypeWhereUniqueInput
  ) => TrainingTypePromise;
  deleteManyTrainingTypes: (
    where?: TrainingTypeWhereInput
  ) => BatchPayloadPromise;
  createUser: (data: UserCreateInput) => UserPromise;
  updateUser: (args: {
    data: UserUpdateInput;
    where: UserWhereUniqueInput;
  }) => UserPromise;
  updateManyUsers: (args: {
    data: UserUpdateManyMutationInput;
    where?: UserWhereInput;
  }) => BatchPayloadPromise;
  upsertUser: (args: {
    where: UserWhereUniqueInput;
    create: UserCreateInput;
    update: UserUpdateInput;
  }) => UserPromise;
  deleteUser: (where: UserWhereUniqueInput) => UserPromise;
  deleteManyUsers: (where?: UserWhereInput) => BatchPayloadPromise;
  createVideo: (data: VideoCreateInput) => VideoPromise;
  updateVideo: (args: {
    data: VideoUpdateInput;
    where: VideoWhereUniqueInput;
  }) => VideoPromise;
  updateManyVideos: (args: {
    data: VideoUpdateManyMutationInput;
    where?: VideoWhereInput;
  }) => BatchPayloadPromise;
  upsertVideo: (args: {
    where: VideoWhereUniqueInput;
    create: VideoCreateInput;
    update: VideoUpdateInput;
  }) => VideoPromise;
  deleteVideo: (where: VideoWhereUniqueInput) => VideoPromise;
  deleteManyVideos: (where?: VideoWhereInput) => BatchPayloadPromise;

  /**
   * Subscriptions
   */

  $subscribe: Subscription;
}

export interface Subscription {
  block: (
    where?: BlockSubscriptionWhereInput
  ) => BlockSubscriptionPayloadSubscription;
  blockInstance: (
    where?: BlockInstanceSubscriptionWhereInput
  ) => BlockInstanceSubscriptionPayloadSubscription;
  comment: (
    where?: CommentSubscriptionWhereInput
  ) => CommentSubscriptionPayloadSubscription;
  exercise: (
    where?: ExerciseSubscriptionWhereInput
  ) => ExerciseSubscriptionPayloadSubscription;
  exerciseInstance: (
    where?: ExerciseInstanceSubscriptionWhereInput
  ) => ExerciseInstanceSubscriptionPayloadSubscription;
  file: (
    where?: FileSubscriptionWhereInput
  ) => FileSubscriptionPayloadSubscription;
  format: (
    where?: FormatSubscriptionWhereInput
  ) => FormatSubscriptionPayloadSubscription;
  link: (
    where?: LinkSubscriptionWhereInput
  ) => LinkSubscriptionPayloadSubscription;
  picture: (
    where?: PictureSubscriptionWhereInput
  ) => PictureSubscriptionPayloadSubscription;
  rating: (
    where?: RatingSubscriptionWhereInput
  ) => RatingSubscriptionPayloadSubscription;
  track: (
    where?: TrackSubscriptionWhereInput
  ) => TrackSubscriptionPayloadSubscription;
  training: (
    where?: TrainingSubscriptionWhereInput
  ) => TrainingSubscriptionPayloadSubscription;
  trainingType: (
    where?: TrainingTypeSubscriptionWhereInput
  ) => TrainingTypeSubscriptionPayloadSubscription;
  user: (
    where?: UserSubscriptionWhereInput
  ) => UserSubscriptionPayloadSubscription;
  video: (
    where?: VideoSubscriptionWhereInput
  ) => VideoSubscriptionPayloadSubscription;
}

export interface ClientConstructor<T> {
  new (options?: BaseClientOptions): T;
}

/**
 * Types
 */

export type TrackOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC"
  | "order_ASC"
  | "order_DESC";

export type CommentOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "text_ASC"
  | "text_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC";

export type RatingOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "value_ASC"
  | "value_DESC"
  | "comment_ASC"
  | "comment_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC";

export type Permission = "ADMIN" | "INSTRUCTOR";

export type VideoOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC"
  | "order_ASC"
  | "order_DESC";

export type PictureOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC"
  | "order_ASC"
  | "order_DESC";

export type BlockInstanceOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "order_ASC"
  | "order_DESC"
  | "rounds_ASC"
  | "rounds_DESC"
  | "variation_ASC"
  | "variation_DESC";

export type UserOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "email_ASC"
  | "email_DESC"
  | "name_ASC"
  | "name_DESC"
  | "password_ASC"
  | "password_DESC"
  | "resetToken_ASC"
  | "resetToken_DESC"
  | "resetTokenExpiry_ASC"
  | "resetTokenExpiry_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC";

export type ExerciseInstanceOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "order_ASC"
  | "order_DESC"
  | "repetitions_ASC"
  | "repetitions_DESC"
  | "variation_ASC"
  | "variation_DESC";

export type BlockOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "title_ASC"
  | "title_DESC"
  | "description_ASC"
  | "description_DESC"
  | "duration_ASC"
  | "duration_DESC"
  | "rest_ASC"
  | "rest_DESC";

export type ExerciseOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC";

export type FileOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC"
  | "path_ASC"
  | "path_DESC"
  | "comment_ASC"
  | "comment_DESC"
  | "mimetype_ASC"
  | "mimetype_DESC"
  | "thumbnail_ASC"
  | "thumbnail_DESC"
  | "filename_ASC"
  | "filename_DESC"
  | "encoding_ASC"
  | "encoding_DESC"
  | "size_ASC"
  | "size_DESC"
  | "width_ASC"
  | "width_DESC"
  | "height_ASC"
  | "height_DESC"
  | "duration_ASC"
  | "duration_DESC"
  | "title_ASC"
  | "title_DESC"
  | "artist_ASC"
  | "artist_DESC";

export type FormatOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC";

export type LinkOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "updatedAt_ASC"
  | "updatedAt_DESC"
  | "url_ASC"
  | "url_DESC"
  | "comment_ASC"
  | "comment_DESC"
  | "duration_ASC"
  | "duration_DESC"
  | "title_ASC"
  | "title_DESC"
  | "artist_ASC"
  | "artist_DESC";

export type TrainingOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "title_ASC"
  | "title_DESC"
  | "createdAt_ASC"
  | "createdAt_DESC"
  | "trainingDate_ASC"
  | "trainingDate_DESC"
  | "location_ASC"
  | "location_DESC"
  | "attendance_ASC"
  | "attendance_DESC"
  | "published_ASC"
  | "published_DESC";

export type TrainingTypeOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC"
  | "description_ASC"
  | "description_DESC";

export type MutationType = "CREATED" | "UPDATED" | "DELETED";

export type BlockWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export interface TrackWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  file?: Maybe<FileWhereInput>;
  link?: Maybe<LinkWhereInput>;
  AND?: Maybe<TrackWhereInput[] | TrackWhereInput>;
  OR?: Maybe<TrackWhereInput[] | TrackWhereInput>;
  NOT?: Maybe<TrackWhereInput[] | TrackWhereInput>;
}

export interface FileWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  user?: Maybe<UserWhereInput>;
  path?: Maybe<String>;
  path_not?: Maybe<String>;
  path_in?: Maybe<String[] | String>;
  path_not_in?: Maybe<String[] | String>;
  path_lt?: Maybe<String>;
  path_lte?: Maybe<String>;
  path_gt?: Maybe<String>;
  path_gte?: Maybe<String>;
  path_contains?: Maybe<String>;
  path_not_contains?: Maybe<String>;
  path_starts_with?: Maybe<String>;
  path_not_starts_with?: Maybe<String>;
  path_ends_with?: Maybe<String>;
  path_not_ends_with?: Maybe<String>;
  comment?: Maybe<String>;
  comment_not?: Maybe<String>;
  comment_in?: Maybe<String[] | String>;
  comment_not_in?: Maybe<String[] | String>;
  comment_lt?: Maybe<String>;
  comment_lte?: Maybe<String>;
  comment_gt?: Maybe<String>;
  comment_gte?: Maybe<String>;
  comment_contains?: Maybe<String>;
  comment_not_contains?: Maybe<String>;
  comment_starts_with?: Maybe<String>;
  comment_not_starts_with?: Maybe<String>;
  comment_ends_with?: Maybe<String>;
  comment_not_ends_with?: Maybe<String>;
  mimetype?: Maybe<String>;
  mimetype_not?: Maybe<String>;
  mimetype_in?: Maybe<String[] | String>;
  mimetype_not_in?: Maybe<String[] | String>;
  mimetype_lt?: Maybe<String>;
  mimetype_lte?: Maybe<String>;
  mimetype_gt?: Maybe<String>;
  mimetype_gte?: Maybe<String>;
  mimetype_contains?: Maybe<String>;
  mimetype_not_contains?: Maybe<String>;
  mimetype_starts_with?: Maybe<String>;
  mimetype_not_starts_with?: Maybe<String>;
  mimetype_ends_with?: Maybe<String>;
  mimetype_not_ends_with?: Maybe<String>;
  thumbnail?: Maybe<String>;
  thumbnail_not?: Maybe<String>;
  thumbnail_in?: Maybe<String[] | String>;
  thumbnail_not_in?: Maybe<String[] | String>;
  thumbnail_lt?: Maybe<String>;
  thumbnail_lte?: Maybe<String>;
  thumbnail_gt?: Maybe<String>;
  thumbnail_gte?: Maybe<String>;
  thumbnail_contains?: Maybe<String>;
  thumbnail_not_contains?: Maybe<String>;
  thumbnail_starts_with?: Maybe<String>;
  thumbnail_not_starts_with?: Maybe<String>;
  thumbnail_ends_with?: Maybe<String>;
  thumbnail_not_ends_with?: Maybe<String>;
  filename?: Maybe<String>;
  filename_not?: Maybe<String>;
  filename_in?: Maybe<String[] | String>;
  filename_not_in?: Maybe<String[] | String>;
  filename_lt?: Maybe<String>;
  filename_lte?: Maybe<String>;
  filename_gt?: Maybe<String>;
  filename_gte?: Maybe<String>;
  filename_contains?: Maybe<String>;
  filename_not_contains?: Maybe<String>;
  filename_starts_with?: Maybe<String>;
  filename_not_starts_with?: Maybe<String>;
  filename_ends_with?: Maybe<String>;
  filename_not_ends_with?: Maybe<String>;
  encoding?: Maybe<String>;
  encoding_not?: Maybe<String>;
  encoding_in?: Maybe<String[] | String>;
  encoding_not_in?: Maybe<String[] | String>;
  encoding_lt?: Maybe<String>;
  encoding_lte?: Maybe<String>;
  encoding_gt?: Maybe<String>;
  encoding_gte?: Maybe<String>;
  encoding_contains?: Maybe<String>;
  encoding_not_contains?: Maybe<String>;
  encoding_starts_with?: Maybe<String>;
  encoding_not_starts_with?: Maybe<String>;
  encoding_ends_with?: Maybe<String>;
  encoding_not_ends_with?: Maybe<String>;
  size?: Maybe<Int>;
  size_not?: Maybe<Int>;
  size_in?: Maybe<Int[] | Int>;
  size_not_in?: Maybe<Int[] | Int>;
  size_lt?: Maybe<Int>;
  size_lte?: Maybe<Int>;
  size_gt?: Maybe<Int>;
  size_gte?: Maybe<Int>;
  width?: Maybe<Int>;
  width_not?: Maybe<Int>;
  width_in?: Maybe<Int[] | Int>;
  width_not_in?: Maybe<Int[] | Int>;
  width_lt?: Maybe<Int>;
  width_lte?: Maybe<Int>;
  width_gt?: Maybe<Int>;
  width_gte?: Maybe<Int>;
  height?: Maybe<Int>;
  height_not?: Maybe<Int>;
  height_in?: Maybe<Int[] | Int>;
  height_not_in?: Maybe<Int[] | Int>;
  height_lt?: Maybe<Int>;
  height_lte?: Maybe<Int>;
  height_gt?: Maybe<Int>;
  height_gte?: Maybe<Int>;
  duration?: Maybe<Float>;
  duration_not?: Maybe<Float>;
  duration_in?: Maybe<Float[] | Float>;
  duration_not_in?: Maybe<Float[] | Float>;
  duration_lt?: Maybe<Float>;
  duration_lte?: Maybe<Float>;
  duration_gt?: Maybe<Float>;
  duration_gte?: Maybe<Float>;
  title?: Maybe<String>;
  title_not?: Maybe<String>;
  title_in?: Maybe<String[] | String>;
  title_not_in?: Maybe<String[] | String>;
  title_lt?: Maybe<String>;
  title_lte?: Maybe<String>;
  title_gt?: Maybe<String>;
  title_gte?: Maybe<String>;
  title_contains?: Maybe<String>;
  title_not_contains?: Maybe<String>;
  title_starts_with?: Maybe<String>;
  title_not_starts_with?: Maybe<String>;
  title_ends_with?: Maybe<String>;
  title_not_ends_with?: Maybe<String>;
  artist?: Maybe<String>;
  artist_not?: Maybe<String>;
  artist_in?: Maybe<String[] | String>;
  artist_not_in?: Maybe<String[] | String>;
  artist_lt?: Maybe<String>;
  artist_lte?: Maybe<String>;
  artist_gt?: Maybe<String>;
  artist_gte?: Maybe<String>;
  artist_contains?: Maybe<String>;
  artist_not_contains?: Maybe<String>;
  artist_starts_with?: Maybe<String>;
  artist_not_starts_with?: Maybe<String>;
  artist_ends_with?: Maybe<String>;
  artist_not_ends_with?: Maybe<String>;
  AND?: Maybe<FileWhereInput[] | FileWhereInput>;
  OR?: Maybe<FileWhereInput[] | FileWhereInput>;
  NOT?: Maybe<FileWhereInput[] | FileWhereInput>;
}

export interface UserWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  email?: Maybe<String>;
  email_not?: Maybe<String>;
  email_in?: Maybe<String[] | String>;
  email_not_in?: Maybe<String[] | String>;
  email_lt?: Maybe<String>;
  email_lte?: Maybe<String>;
  email_gt?: Maybe<String>;
  email_gte?: Maybe<String>;
  email_contains?: Maybe<String>;
  email_not_contains?: Maybe<String>;
  email_starts_with?: Maybe<String>;
  email_not_starts_with?: Maybe<String>;
  email_ends_with?: Maybe<String>;
  email_not_ends_with?: Maybe<String>;
  name?: Maybe<String>;
  name_not?: Maybe<String>;
  name_in?: Maybe<String[] | String>;
  name_not_in?: Maybe<String[] | String>;
  name_lt?: Maybe<String>;
  name_lte?: Maybe<String>;
  name_gt?: Maybe<String>;
  name_gte?: Maybe<String>;
  name_contains?: Maybe<String>;
  name_not_contains?: Maybe<String>;
  name_starts_with?: Maybe<String>;
  name_not_starts_with?: Maybe<String>;
  name_ends_with?: Maybe<String>;
  name_not_ends_with?: Maybe<String>;
  password?: Maybe<String>;
  password_not?: Maybe<String>;
  password_in?: Maybe<String[] | String>;
  password_not_in?: Maybe<String[] | String>;
  password_lt?: Maybe<String>;
  password_lte?: Maybe<String>;
  password_gt?: Maybe<String>;
  password_gte?: Maybe<String>;
  password_contains?: Maybe<String>;
  password_not_contains?: Maybe<String>;
  password_starts_with?: Maybe<String>;
  password_not_starts_with?: Maybe<String>;
  password_ends_with?: Maybe<String>;
  password_not_ends_with?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetToken_not?: Maybe<String>;
  resetToken_in?: Maybe<String[] | String>;
  resetToken_not_in?: Maybe<String[] | String>;
  resetToken_lt?: Maybe<String>;
  resetToken_lte?: Maybe<String>;
  resetToken_gt?: Maybe<String>;
  resetToken_gte?: Maybe<String>;
  resetToken_contains?: Maybe<String>;
  resetToken_not_contains?: Maybe<String>;
  resetToken_starts_with?: Maybe<String>;
  resetToken_not_starts_with?: Maybe<String>;
  resetToken_ends_with?: Maybe<String>;
  resetToken_not_ends_with?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  resetTokenExpiry_not?: Maybe<Float>;
  resetTokenExpiry_in?: Maybe<Float[] | Float>;
  resetTokenExpiry_not_in?: Maybe<Float[] | Float>;
  resetTokenExpiry_lt?: Maybe<Float>;
  resetTokenExpiry_lte?: Maybe<Float>;
  resetTokenExpiry_gt?: Maybe<Float>;
  resetTokenExpiry_gte?: Maybe<Float>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  comments_every?: Maybe<CommentWhereInput>;
  comments_some?: Maybe<CommentWhereInput>;
  comments_none?: Maybe<CommentWhereInput>;
  ratings_every?: Maybe<RatingWhereInput>;
  ratings_some?: Maybe<RatingWhereInput>;
  ratings_none?: Maybe<RatingWhereInput>;
  AND?: Maybe<UserWhereInput[] | UserWhereInput>;
  OR?: Maybe<UserWhereInput[] | UserWhereInput>;
  NOT?: Maybe<UserWhereInput[] | UserWhereInput>;
}

export interface CommentWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  text?: Maybe<String>;
  text_not?: Maybe<String>;
  text_in?: Maybe<String[] | String>;
  text_not_in?: Maybe<String[] | String>;
  text_lt?: Maybe<String>;
  text_lte?: Maybe<String>;
  text_gt?: Maybe<String>;
  text_gte?: Maybe<String>;
  text_contains?: Maybe<String>;
  text_not_contains?: Maybe<String>;
  text_starts_with?: Maybe<String>;
  text_not_starts_with?: Maybe<String>;
  text_ends_with?: Maybe<String>;
  text_not_ends_with?: Maybe<String>;
  author?: Maybe<UserWhereInput>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  AND?: Maybe<CommentWhereInput[] | CommentWhereInput>;
  OR?: Maybe<CommentWhereInput[] | CommentWhereInput>;
  NOT?: Maybe<CommentWhereInput[] | CommentWhereInput>;
}

export interface RatingWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  user?: Maybe<UserWhereInput>;
  value?: Maybe<Int>;
  value_not?: Maybe<Int>;
  value_in?: Maybe<Int[] | Int>;
  value_not_in?: Maybe<Int[] | Int>;
  value_lt?: Maybe<Int>;
  value_lte?: Maybe<Int>;
  value_gt?: Maybe<Int>;
  value_gte?: Maybe<Int>;
  comment?: Maybe<String>;
  comment_not?: Maybe<String>;
  comment_in?: Maybe<String[] | String>;
  comment_not_in?: Maybe<String[] | String>;
  comment_lt?: Maybe<String>;
  comment_lte?: Maybe<String>;
  comment_gt?: Maybe<String>;
  comment_gte?: Maybe<String>;
  comment_contains?: Maybe<String>;
  comment_not_contains?: Maybe<String>;
  comment_starts_with?: Maybe<String>;
  comment_not_starts_with?: Maybe<String>;
  comment_ends_with?: Maybe<String>;
  comment_not_ends_with?: Maybe<String>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  AND?: Maybe<RatingWhereInput[] | RatingWhereInput>;
  OR?: Maybe<RatingWhereInput[] | RatingWhereInput>;
  NOT?: Maybe<RatingWhereInput[] | RatingWhereInput>;
}

export interface LinkWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  url?: Maybe<String>;
  url_not?: Maybe<String>;
  url_in?: Maybe<String[] | String>;
  url_not_in?: Maybe<String[] | String>;
  url_lt?: Maybe<String>;
  url_lte?: Maybe<String>;
  url_gt?: Maybe<String>;
  url_gte?: Maybe<String>;
  url_contains?: Maybe<String>;
  url_not_contains?: Maybe<String>;
  url_starts_with?: Maybe<String>;
  url_not_starts_with?: Maybe<String>;
  url_ends_with?: Maybe<String>;
  url_not_ends_with?: Maybe<String>;
  user?: Maybe<UserWhereInput>;
  comment?: Maybe<String>;
  comment_not?: Maybe<String>;
  comment_in?: Maybe<String[] | String>;
  comment_not_in?: Maybe<String[] | String>;
  comment_lt?: Maybe<String>;
  comment_lte?: Maybe<String>;
  comment_gt?: Maybe<String>;
  comment_gte?: Maybe<String>;
  comment_contains?: Maybe<String>;
  comment_not_contains?: Maybe<String>;
  comment_starts_with?: Maybe<String>;
  comment_not_starts_with?: Maybe<String>;
  comment_ends_with?: Maybe<String>;
  comment_not_ends_with?: Maybe<String>;
  duration?: Maybe<Int>;
  duration_not?: Maybe<Int>;
  duration_in?: Maybe<Int[] | Int>;
  duration_not_in?: Maybe<Int[] | Int>;
  duration_lt?: Maybe<Int>;
  duration_lte?: Maybe<Int>;
  duration_gt?: Maybe<Int>;
  duration_gte?: Maybe<Int>;
  title?: Maybe<String>;
  title_not?: Maybe<String>;
  title_in?: Maybe<String[] | String>;
  title_not_in?: Maybe<String[] | String>;
  title_lt?: Maybe<String>;
  title_lte?: Maybe<String>;
  title_gt?: Maybe<String>;
  title_gte?: Maybe<String>;
  title_contains?: Maybe<String>;
  title_not_contains?: Maybe<String>;
  title_starts_with?: Maybe<String>;
  title_not_starts_with?: Maybe<String>;
  title_ends_with?: Maybe<String>;
  title_not_ends_with?: Maybe<String>;
  artist?: Maybe<String>;
  artist_not?: Maybe<String>;
  artist_in?: Maybe<String[] | String>;
  artist_not_in?: Maybe<String[] | String>;
  artist_lt?: Maybe<String>;
  artist_lte?: Maybe<String>;
  artist_gt?: Maybe<String>;
  artist_gte?: Maybe<String>;
  artist_contains?: Maybe<String>;
  artist_not_contains?: Maybe<String>;
  artist_starts_with?: Maybe<String>;
  artist_not_starts_with?: Maybe<String>;
  artist_ends_with?: Maybe<String>;
  artist_not_ends_with?: Maybe<String>;
  AND?: Maybe<LinkWhereInput[] | LinkWhereInput>;
  OR?: Maybe<LinkWhereInput[] | LinkWhereInput>;
  NOT?: Maybe<LinkWhereInput[] | LinkWhereInput>;
}

export interface VideoWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  file?: Maybe<FileWhereInput>;
  link?: Maybe<LinkWhereInput>;
  AND?: Maybe<VideoWhereInput[] | VideoWhereInput>;
  OR?: Maybe<VideoWhereInput[] | VideoWhereInput>;
  NOT?: Maybe<VideoWhereInput[] | VideoWhereInput>;
}

export interface PictureWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  file?: Maybe<FileWhereInput>;
  link?: Maybe<LinkWhereInput>;
  AND?: Maybe<PictureWhereInput[] | PictureWhereInput>;
  OR?: Maybe<PictureWhereInput[] | PictureWhereInput>;
  NOT?: Maybe<PictureWhereInput[] | PictureWhereInput>;
}

export interface BlockInstanceWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  block?: Maybe<BlockWhereInput>;
  parentBlock?: Maybe<BlockWhereInput>;
  parentTraining?: Maybe<TrainingWhereInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  rounds?: Maybe<Int>;
  rounds_not?: Maybe<Int>;
  rounds_in?: Maybe<Int[] | Int>;
  rounds_not_in?: Maybe<Int[] | Int>;
  rounds_lt?: Maybe<Int>;
  rounds_lte?: Maybe<Int>;
  rounds_gt?: Maybe<Int>;
  rounds_gte?: Maybe<Int>;
  variation?: Maybe<String>;
  variation_not?: Maybe<String>;
  variation_in?: Maybe<String[] | String>;
  variation_not_in?: Maybe<String[] | String>;
  variation_lt?: Maybe<String>;
  variation_lte?: Maybe<String>;
  variation_gt?: Maybe<String>;
  variation_gte?: Maybe<String>;
  variation_contains?: Maybe<String>;
  variation_not_contains?: Maybe<String>;
  variation_starts_with?: Maybe<String>;
  variation_not_starts_with?: Maybe<String>;
  variation_ends_with?: Maybe<String>;
  variation_not_ends_with?: Maybe<String>;
  AND?: Maybe<BlockInstanceWhereInput[] | BlockInstanceWhereInput>;
  OR?: Maybe<BlockInstanceWhereInput[] | BlockInstanceWhereInput>;
  NOT?: Maybe<BlockInstanceWhereInput[] | BlockInstanceWhereInput>;
}

export interface BlockWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  title?: Maybe<String>;
  title_not?: Maybe<String>;
  title_in?: Maybe<String[] | String>;
  title_not_in?: Maybe<String[] | String>;
  title_lt?: Maybe<String>;
  title_lte?: Maybe<String>;
  title_gt?: Maybe<String>;
  title_gte?: Maybe<String>;
  title_contains?: Maybe<String>;
  title_not_contains?: Maybe<String>;
  title_starts_with?: Maybe<String>;
  title_not_starts_with?: Maybe<String>;
  title_ends_with?: Maybe<String>;
  title_not_ends_with?: Maybe<String>;
  description?: Maybe<String>;
  description_not?: Maybe<String>;
  description_in?: Maybe<String[] | String>;
  description_not_in?: Maybe<String[] | String>;
  description_lt?: Maybe<String>;
  description_lte?: Maybe<String>;
  description_gt?: Maybe<String>;
  description_gte?: Maybe<String>;
  description_contains?: Maybe<String>;
  description_not_contains?: Maybe<String>;
  description_starts_with?: Maybe<String>;
  description_not_starts_with?: Maybe<String>;
  description_ends_with?: Maybe<String>;
  description_not_ends_with?: Maybe<String>;
  duration?: Maybe<Int>;
  duration_not?: Maybe<Int>;
  duration_in?: Maybe<Int[] | Int>;
  duration_not_in?: Maybe<Int[] | Int>;
  duration_lt?: Maybe<Int>;
  duration_lte?: Maybe<Int>;
  duration_gt?: Maybe<Int>;
  duration_gte?: Maybe<Int>;
  format?: Maybe<FormatWhereInput>;
  rest?: Maybe<Int>;
  rest_not?: Maybe<Int>;
  rest_in?: Maybe<Int[] | Int>;
  rest_not_in?: Maybe<Int[] | Int>;
  rest_lt?: Maybe<Int>;
  rest_lte?: Maybe<Int>;
  rest_gt?: Maybe<Int>;
  rest_gte?: Maybe<Int>;
  tracks_every?: Maybe<TrackWhereInput>;
  tracks_some?: Maybe<TrackWhereInput>;
  tracks_none?: Maybe<TrackWhereInput>;
  videos_every?: Maybe<VideoWhereInput>;
  videos_some?: Maybe<VideoWhereInput>;
  videos_none?: Maybe<VideoWhereInput>;
  pictures_every?: Maybe<PictureWhereInput>;
  pictures_some?: Maybe<PictureWhereInput>;
  pictures_none?: Maybe<PictureWhereInput>;
  blocks_every?: Maybe<BlockInstanceWhereInput>;
  blocks_some?: Maybe<BlockInstanceWhereInput>;
  blocks_none?: Maybe<BlockInstanceWhereInput>;
  parentBlockInstances_every?: Maybe<BlockInstanceWhereInput>;
  parentBlockInstances_some?: Maybe<BlockInstanceWhereInput>;
  parentBlockInstances_none?: Maybe<BlockInstanceWhereInput>;
  exercises_every?: Maybe<ExerciseInstanceWhereInput>;
  exercises_some?: Maybe<ExerciseInstanceWhereInput>;
  exercises_none?: Maybe<ExerciseInstanceWhereInput>;
  AND?: Maybe<BlockWhereInput[] | BlockWhereInput>;
  OR?: Maybe<BlockWhereInput[] | BlockWhereInput>;
  NOT?: Maybe<BlockWhereInput[] | BlockWhereInput>;
}

export interface FormatWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  name?: Maybe<String>;
  name_not?: Maybe<String>;
  name_in?: Maybe<String[] | String>;
  name_not_in?: Maybe<String[] | String>;
  name_lt?: Maybe<String>;
  name_lte?: Maybe<String>;
  name_gt?: Maybe<String>;
  name_gte?: Maybe<String>;
  name_contains?: Maybe<String>;
  name_not_contains?: Maybe<String>;
  name_starts_with?: Maybe<String>;
  name_not_starts_with?: Maybe<String>;
  name_ends_with?: Maybe<String>;
  name_not_ends_with?: Maybe<String>;
  description?: Maybe<String>;
  description_not?: Maybe<String>;
  description_in?: Maybe<String[] | String>;
  description_not_in?: Maybe<String[] | String>;
  description_lt?: Maybe<String>;
  description_lte?: Maybe<String>;
  description_gt?: Maybe<String>;
  description_gte?: Maybe<String>;
  description_contains?: Maybe<String>;
  description_not_contains?: Maybe<String>;
  description_starts_with?: Maybe<String>;
  description_not_starts_with?: Maybe<String>;
  description_ends_with?: Maybe<String>;
  description_not_ends_with?: Maybe<String>;
  AND?: Maybe<FormatWhereInput[] | FormatWhereInput>;
  OR?: Maybe<FormatWhereInput[] | FormatWhereInput>;
  NOT?: Maybe<FormatWhereInput[] | FormatWhereInput>;
}

export interface ExerciseInstanceWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  exercise?: Maybe<ExerciseWhereInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  repetitions_not?: Maybe<Int>;
  repetitions_in?: Maybe<Int[] | Int>;
  repetitions_not_in?: Maybe<Int[] | Int>;
  repetitions_lt?: Maybe<Int>;
  repetitions_lte?: Maybe<Int>;
  repetitions_gt?: Maybe<Int>;
  repetitions_gte?: Maybe<Int>;
  variation?: Maybe<String>;
  variation_not?: Maybe<String>;
  variation_in?: Maybe<String[] | String>;
  variation_not_in?: Maybe<String[] | String>;
  variation_lt?: Maybe<String>;
  variation_lte?: Maybe<String>;
  variation_gt?: Maybe<String>;
  variation_gte?: Maybe<String>;
  variation_contains?: Maybe<String>;
  variation_not_contains?: Maybe<String>;
  variation_starts_with?: Maybe<String>;
  variation_not_starts_with?: Maybe<String>;
  variation_ends_with?: Maybe<String>;
  variation_not_ends_with?: Maybe<String>;
  parentBlockInstances?: Maybe<BlockWhereInput>;
  AND?: Maybe<ExerciseInstanceWhereInput[] | ExerciseInstanceWhereInput>;
  OR?: Maybe<ExerciseInstanceWhereInput[] | ExerciseInstanceWhereInput>;
  NOT?: Maybe<ExerciseInstanceWhereInput[] | ExerciseInstanceWhereInput>;
}

export interface ExerciseWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  name?: Maybe<String>;
  name_not?: Maybe<String>;
  name_in?: Maybe<String[] | String>;
  name_not_in?: Maybe<String[] | String>;
  name_lt?: Maybe<String>;
  name_lte?: Maybe<String>;
  name_gt?: Maybe<String>;
  name_gte?: Maybe<String>;
  name_contains?: Maybe<String>;
  name_not_contains?: Maybe<String>;
  name_starts_with?: Maybe<String>;
  name_not_starts_with?: Maybe<String>;
  name_ends_with?: Maybe<String>;
  name_not_ends_with?: Maybe<String>;
  description?: Maybe<String>;
  description_not?: Maybe<String>;
  description_in?: Maybe<String[] | String>;
  description_not_in?: Maybe<String[] | String>;
  description_lt?: Maybe<String>;
  description_lte?: Maybe<String>;
  description_gt?: Maybe<String>;
  description_gte?: Maybe<String>;
  description_contains?: Maybe<String>;
  description_not_contains?: Maybe<String>;
  description_starts_with?: Maybe<String>;
  description_not_starts_with?: Maybe<String>;
  description_ends_with?: Maybe<String>;
  description_not_ends_with?: Maybe<String>;
  videos_every?: Maybe<VideoWhereInput>;
  videos_some?: Maybe<VideoWhereInput>;
  videos_none?: Maybe<VideoWhereInput>;
  pictures_every?: Maybe<PictureWhereInput>;
  pictures_some?: Maybe<PictureWhereInput>;
  pictures_none?: Maybe<PictureWhereInput>;
  parentExerciseInstances_every?: Maybe<ExerciseInstanceWhereInput>;
  parentExerciseInstances_some?: Maybe<ExerciseInstanceWhereInput>;
  parentExerciseInstances_none?: Maybe<ExerciseInstanceWhereInput>;
  AND?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
  OR?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
  NOT?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
}

export interface TrainingWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  title?: Maybe<String>;
  title_not?: Maybe<String>;
  title_in?: Maybe<String[] | String>;
  title_not_in?: Maybe<String[] | String>;
  title_lt?: Maybe<String>;
  title_lte?: Maybe<String>;
  title_gt?: Maybe<String>;
  title_gte?: Maybe<String>;
  title_contains?: Maybe<String>;
  title_not_contains?: Maybe<String>;
  title_starts_with?: Maybe<String>;
  title_not_starts_with?: Maybe<String>;
  title_ends_with?: Maybe<String>;
  title_not_ends_with?: Maybe<String>;
  type?: Maybe<TrainingTypeWhereInput>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  trainingDate?: Maybe<DateTimeInput>;
  trainingDate_not?: Maybe<DateTimeInput>;
  trainingDate_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  trainingDate_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  trainingDate_lt?: Maybe<DateTimeInput>;
  trainingDate_lte?: Maybe<DateTimeInput>;
  trainingDate_gt?: Maybe<DateTimeInput>;
  trainingDate_gte?: Maybe<DateTimeInput>;
  location?: Maybe<String>;
  location_not?: Maybe<String>;
  location_in?: Maybe<String[] | String>;
  location_not_in?: Maybe<String[] | String>;
  location_lt?: Maybe<String>;
  location_lte?: Maybe<String>;
  location_gt?: Maybe<String>;
  location_gte?: Maybe<String>;
  location_contains?: Maybe<String>;
  location_not_contains?: Maybe<String>;
  location_starts_with?: Maybe<String>;
  location_not_starts_with?: Maybe<String>;
  location_ends_with?: Maybe<String>;
  location_not_ends_with?: Maybe<String>;
  registrations_every?: Maybe<UserWhereInput>;
  registrations_some?: Maybe<UserWhereInput>;
  registrations_none?: Maybe<UserWhereInput>;
  attendance?: Maybe<Int>;
  attendance_not?: Maybe<Int>;
  attendance_in?: Maybe<Int[] | Int>;
  attendance_not_in?: Maybe<Int[] | Int>;
  attendance_lt?: Maybe<Int>;
  attendance_lte?: Maybe<Int>;
  attendance_gt?: Maybe<Int>;
  attendance_gte?: Maybe<Int>;
  ratings_every?: Maybe<RatingWhereInput>;
  ratings_some?: Maybe<RatingWhereInput>;
  ratings_none?: Maybe<RatingWhereInput>;
  published?: Maybe<Boolean>;
  published_not?: Maybe<Boolean>;
  blocks_every?: Maybe<BlockInstanceWhereInput>;
  blocks_some?: Maybe<BlockInstanceWhereInput>;
  blocks_none?: Maybe<BlockInstanceWhereInput>;
  AND?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
  OR?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
  NOT?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
}

export interface TrainingTypeWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  name?: Maybe<String>;
  name_not?: Maybe<String>;
  name_in?: Maybe<String[] | String>;
  name_not_in?: Maybe<String[] | String>;
  name_lt?: Maybe<String>;
  name_lte?: Maybe<String>;
  name_gt?: Maybe<String>;
  name_gte?: Maybe<String>;
  name_contains?: Maybe<String>;
  name_not_contains?: Maybe<String>;
  name_starts_with?: Maybe<String>;
  name_not_starts_with?: Maybe<String>;
  name_ends_with?: Maybe<String>;
  name_not_ends_with?: Maybe<String>;
  description?: Maybe<String>;
  description_not?: Maybe<String>;
  description_in?: Maybe<String[] | String>;
  description_not_in?: Maybe<String[] | String>;
  description_lt?: Maybe<String>;
  description_lte?: Maybe<String>;
  description_gt?: Maybe<String>;
  description_gte?: Maybe<String>;
  description_contains?: Maybe<String>;
  description_not_contains?: Maybe<String>;
  description_starts_with?: Maybe<String>;
  description_not_starts_with?: Maybe<String>;
  description_ends_with?: Maybe<String>;
  description_not_ends_with?: Maybe<String>;
  AND?: Maybe<TrainingTypeWhereInput[] | TrainingTypeWhereInput>;
  OR?: Maybe<TrainingTypeWhereInput[] | TrainingTypeWhereInput>;
  NOT?: Maybe<TrainingTypeWhereInput[] | TrainingTypeWhereInput>;
}

export type BlockInstanceWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type CommentWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type ExerciseWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type ExerciseInstanceWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type FileWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type FormatWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type LinkWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type PictureWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type RatingWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type TrackWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type TrainingWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type TrainingTypeWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
  name?: Maybe<String>;
}>;

export type UserWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
  email?: Maybe<String>;
}>;

export type VideoWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export interface BlockCreateInput {
  id?: Maybe<ID_Input>;
  title: String;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format: FormatCreateOneInput;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackCreateManyInput>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  blocks?: Maybe<BlockInstanceCreateManyWithoutParentBlockInput>;
  parentBlockInstances?: Maybe<BlockInstanceCreateManyWithoutBlockInput>;
  exercises?: Maybe<ExerciseInstanceCreateManyWithoutParentBlockInstancesInput>;
}

export interface FormatCreateOneInput {
  create?: Maybe<FormatCreateInput>;
  connect?: Maybe<FormatWhereUniqueInput>;
}

export interface FormatCreateInput {
  id?: Maybe<ID_Input>;
  name: String;
  description: String;
}

export interface TrackCreateManyInput {
  create?: Maybe<TrackCreateInput[] | TrackCreateInput>;
  connect?: Maybe<TrackWhereUniqueInput[] | TrackWhereUniqueInput>;
}

export interface TrackCreateInput {
  id?: Maybe<ID_Input>;
  order: Int;
  file?: Maybe<FileCreateOneInput>;
  link?: Maybe<LinkCreateOneInput>;
}

export interface FileCreateOneInput {
  create?: Maybe<FileCreateInput>;
  connect?: Maybe<FileWhereUniqueInput>;
}

export interface FileCreateInput {
  id?: Maybe<ID_Input>;
  user: UserCreateOneInput;
  path: String;
  comment?: Maybe<String>;
  mimetype?: Maybe<String>;
  thumbnail?: Maybe<String>;
  filename?: Maybe<String>;
  encoding?: Maybe<String>;
  size?: Maybe<Int>;
  width?: Maybe<Int>;
  height?: Maybe<Int>;
  duration?: Maybe<Float>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface UserCreateOneInput {
  create?: Maybe<UserCreateInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserCreateInput {
  id?: Maybe<ID_Input>;
  email: String;
  name: String;
  password: String;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  comments?: Maybe<CommentCreateManyWithoutAuthorInput>;
  ratings?: Maybe<RatingCreateManyWithoutUserInput>;
  permissions?: Maybe<UserCreatepermissionsInput>;
  interests?: Maybe<UserCreateinterestsInput>;
}

export interface CommentCreateManyWithoutAuthorInput {
  create?: Maybe<
    CommentCreateWithoutAuthorInput[] | CommentCreateWithoutAuthorInput
  >;
  connect?: Maybe<CommentWhereUniqueInput[] | CommentWhereUniqueInput>;
}

export interface CommentCreateWithoutAuthorInput {
  id?: Maybe<ID_Input>;
  text: String;
}

export interface RatingCreateManyWithoutUserInput {
  create?: Maybe<RatingCreateWithoutUserInput[] | RatingCreateWithoutUserInput>;
  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
}

export interface RatingCreateWithoutUserInput {
  id?: Maybe<ID_Input>;
  value: Int;
  comment: String;
}

export interface UserCreatepermissionsInput {
  set?: Maybe<Permission[] | Permission>;
}

export interface UserCreateinterestsInput {
  set?: Maybe<String[] | String>;
}

export interface LinkCreateOneInput {
  create?: Maybe<LinkCreateInput>;
  connect?: Maybe<LinkWhereUniqueInput>;
}

export interface LinkCreateInput {
  id?: Maybe<ID_Input>;
  url: String;
  user: UserCreateOneInput;
  comment?: Maybe<String>;
  duration?: Maybe<Int>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface VideoCreateManyInput {
  create?: Maybe<VideoCreateInput[] | VideoCreateInput>;
  connect?: Maybe<VideoWhereUniqueInput[] | VideoWhereUniqueInput>;
}

export interface VideoCreateInput {
  id?: Maybe<ID_Input>;
  order: Int;
  file?: Maybe<FileCreateOneInput>;
  link?: Maybe<LinkCreateOneInput>;
}

export interface PictureCreateManyInput {
  create?: Maybe<PictureCreateInput[] | PictureCreateInput>;
  connect?: Maybe<PictureWhereUniqueInput[] | PictureWhereUniqueInput>;
}

export interface PictureCreateInput {
  id?: Maybe<ID_Input>;
  order: Int;
  file?: Maybe<FileCreateOneInput>;
  link?: Maybe<LinkCreateOneInput>;
}

export interface BlockInstanceCreateManyWithoutParentBlockInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutParentBlockInput[]
    | BlockInstanceCreateWithoutParentBlockInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
}

export interface BlockInstanceCreateWithoutParentBlockInput {
  id?: Maybe<ID_Input>;
  block: BlockCreateOneWithoutParentBlockInstancesInput;
  parentTraining?: Maybe<TrainingCreateOneWithoutBlocksInput>;
  order: Int;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockCreateOneWithoutParentBlockInstancesInput {
  create?: Maybe<BlockCreateWithoutParentBlockInstancesInput>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockCreateWithoutParentBlockInstancesInput {
  id?: Maybe<ID_Input>;
  title: String;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format: FormatCreateOneInput;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackCreateManyInput>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  blocks?: Maybe<BlockInstanceCreateManyWithoutParentBlockInput>;
  exercises?: Maybe<ExerciseInstanceCreateManyWithoutParentBlockInstancesInput>;
}

export interface ExerciseInstanceCreateManyWithoutParentBlockInstancesInput {
  create?: Maybe<
    | ExerciseInstanceCreateWithoutParentBlockInstancesInput[]
    | ExerciseInstanceCreateWithoutParentBlockInstancesInput
  >;
  connect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
}

export interface ExerciseInstanceCreateWithoutParentBlockInstancesInput {
  id?: Maybe<ID_Input>;
  exercise: ExerciseCreateOneWithoutParentExerciseInstancesInput;
  order: Int;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface ExerciseCreateOneWithoutParentExerciseInstancesInput {
  create?: Maybe<ExerciseCreateWithoutParentExerciseInstancesInput>;
  connect?: Maybe<ExerciseWhereUniqueInput>;
}

export interface ExerciseCreateWithoutParentExerciseInstancesInput {
  id?: Maybe<ID_Input>;
  name: String;
  description?: Maybe<String>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  targets?: Maybe<ExerciseCreatetargetsInput>;
  baseExercise?: Maybe<ExerciseCreatebaseExerciseInput>;
}

export interface ExerciseCreatetargetsInput {
  set?: Maybe<String[] | String>;
}

export interface ExerciseCreatebaseExerciseInput {
  set?: Maybe<String[] | String>;
}

export interface TrainingCreateOneWithoutBlocksInput {
  create?: Maybe<TrainingCreateWithoutBlocksInput>;
  connect?: Maybe<TrainingWhereUniqueInput>;
}

export interface TrainingCreateWithoutBlocksInput {
  id?: Maybe<ID_Input>;
  title: String;
  type: TrainingTypeCreateOneInput;
  trainingDate: DateTimeInput;
  location: String;
  registrations?: Maybe<UserCreateManyInput>;
  attendance?: Maybe<Int>;
  ratings?: Maybe<RatingCreateManyInput>;
  published: Boolean;
}

export interface TrainingTypeCreateOneInput {
  create?: Maybe<TrainingTypeCreateInput>;
  connect?: Maybe<TrainingTypeWhereUniqueInput>;
}

export interface TrainingTypeCreateInput {
  id?: Maybe<ID_Input>;
  name: String;
  description: String;
}

export interface UserCreateManyInput {
  create?: Maybe<UserCreateInput[] | UserCreateInput>;
  connect?: Maybe<UserWhereUniqueInput[] | UserWhereUniqueInput>;
}

export interface RatingCreateManyInput {
  create?: Maybe<RatingCreateInput[] | RatingCreateInput>;
  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
}

export interface RatingCreateInput {
  id?: Maybe<ID_Input>;
  user: UserCreateOneWithoutRatingsInput;
  value: Int;
  comment: String;
}

export interface UserCreateOneWithoutRatingsInput {
  create?: Maybe<UserCreateWithoutRatingsInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserCreateWithoutRatingsInput {
  id?: Maybe<ID_Input>;
  email: String;
  name: String;
  password: String;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  comments?: Maybe<CommentCreateManyWithoutAuthorInput>;
  permissions?: Maybe<UserCreatepermissionsInput>;
  interests?: Maybe<UserCreateinterestsInput>;
}

export interface BlockInstanceCreateManyWithoutBlockInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutBlockInput[]
    | BlockInstanceCreateWithoutBlockInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
}

export interface BlockInstanceCreateWithoutBlockInput {
  id?: Maybe<ID_Input>;
  parentBlock?: Maybe<BlockCreateOneWithoutBlocksInput>;
  parentTraining?: Maybe<TrainingCreateOneWithoutBlocksInput>;
  order: Int;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockCreateOneWithoutBlocksInput {
  create?: Maybe<BlockCreateWithoutBlocksInput>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockCreateWithoutBlocksInput {
  id?: Maybe<ID_Input>;
  title: String;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format: FormatCreateOneInput;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackCreateManyInput>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  parentBlockInstances?: Maybe<BlockInstanceCreateManyWithoutBlockInput>;
  exercises?: Maybe<ExerciseInstanceCreateManyWithoutParentBlockInstancesInput>;
}

export interface BlockUpdateInput {
  title?: Maybe<String>;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format?: Maybe<FormatUpdateOneRequiredInput>;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackUpdateManyInput>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  blocks?: Maybe<BlockInstanceUpdateManyWithoutParentBlockInput>;
  parentBlockInstances?: Maybe<BlockInstanceUpdateManyWithoutBlockInput>;
  exercises?: Maybe<ExerciseInstanceUpdateManyWithoutParentBlockInstancesInput>;
}

export interface FormatUpdateOneRequiredInput {
  create?: Maybe<FormatCreateInput>;
  update?: Maybe<FormatUpdateDataInput>;
  upsert?: Maybe<FormatUpsertNestedInput>;
  connect?: Maybe<FormatWhereUniqueInput>;
}

export interface FormatUpdateDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface FormatUpsertNestedInput {
  update: FormatUpdateDataInput;
  create: FormatCreateInput;
}

export interface TrackUpdateManyInput {
  create?: Maybe<TrackCreateInput[] | TrackCreateInput>;
  update?: Maybe<
    | TrackUpdateWithWhereUniqueNestedInput[]
    | TrackUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | TrackUpsertWithWhereUniqueNestedInput[]
    | TrackUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<TrackWhereUniqueInput[] | TrackWhereUniqueInput>;
  connect?: Maybe<TrackWhereUniqueInput[] | TrackWhereUniqueInput>;
  set?: Maybe<TrackWhereUniqueInput[] | TrackWhereUniqueInput>;
  disconnect?: Maybe<TrackWhereUniqueInput[] | TrackWhereUniqueInput>;
  deleteMany?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
  updateMany?: Maybe<
    TrackUpdateManyWithWhereNestedInput[] | TrackUpdateManyWithWhereNestedInput
  >;
}

export interface TrackUpdateWithWhereUniqueNestedInput {
  where: TrackWhereUniqueInput;
  data: TrackUpdateDataInput;
}

export interface TrackUpdateDataInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface FileUpdateOneInput {
  create?: Maybe<FileCreateInput>;
  update?: Maybe<FileUpdateDataInput>;
  upsert?: Maybe<FileUpsertNestedInput>;
  delete?: Maybe<Boolean>;
  disconnect?: Maybe<Boolean>;
  connect?: Maybe<FileWhereUniqueInput>;
}

export interface FileUpdateDataInput {
  user?: Maybe<UserUpdateOneRequiredInput>;
  path?: Maybe<String>;
  comment?: Maybe<String>;
  mimetype?: Maybe<String>;
  thumbnail?: Maybe<String>;
  filename?: Maybe<String>;
  encoding?: Maybe<String>;
  size?: Maybe<Int>;
  width?: Maybe<Int>;
  height?: Maybe<Int>;
  duration?: Maybe<Float>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface UserUpdateOneRequiredInput {
  create?: Maybe<UserCreateInput>;
  update?: Maybe<UserUpdateDataInput>;
  upsert?: Maybe<UserUpsertNestedInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserUpdateDataInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface CommentUpdateManyWithoutAuthorInput {
  create?: Maybe<
    CommentCreateWithoutAuthorInput[] | CommentCreateWithoutAuthorInput
  >;
  delete?: Maybe<CommentWhereUniqueInput[] | CommentWhereUniqueInput>;
  connect?: Maybe<CommentWhereUniqueInput[] | CommentWhereUniqueInput>;
  set?: Maybe<CommentWhereUniqueInput[] | CommentWhereUniqueInput>;
  disconnect?: Maybe<CommentWhereUniqueInput[] | CommentWhereUniqueInput>;
  update?: Maybe<
    | CommentUpdateWithWhereUniqueWithoutAuthorInput[]
    | CommentUpdateWithWhereUniqueWithoutAuthorInput
  >;
  upsert?: Maybe<
    | CommentUpsertWithWhereUniqueWithoutAuthorInput[]
    | CommentUpsertWithWhereUniqueWithoutAuthorInput
  >;
  deleteMany?: Maybe<CommentScalarWhereInput[] | CommentScalarWhereInput>;
  updateMany?: Maybe<
    | CommentUpdateManyWithWhereNestedInput[]
    | CommentUpdateManyWithWhereNestedInput
  >;
}

export interface CommentUpdateWithWhereUniqueWithoutAuthorInput {
  where: CommentWhereUniqueInput;
  data: CommentUpdateWithoutAuthorDataInput;
}

export interface CommentUpdateWithoutAuthorDataInput {
  text?: Maybe<String>;
}

export interface CommentUpsertWithWhereUniqueWithoutAuthorInput {
  where: CommentWhereUniqueInput;
  update: CommentUpdateWithoutAuthorDataInput;
  create: CommentCreateWithoutAuthorInput;
}

export interface CommentScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  text?: Maybe<String>;
  text_not?: Maybe<String>;
  text_in?: Maybe<String[] | String>;
  text_not_in?: Maybe<String[] | String>;
  text_lt?: Maybe<String>;
  text_lte?: Maybe<String>;
  text_gt?: Maybe<String>;
  text_gte?: Maybe<String>;
  text_contains?: Maybe<String>;
  text_not_contains?: Maybe<String>;
  text_starts_with?: Maybe<String>;
  text_not_starts_with?: Maybe<String>;
  text_ends_with?: Maybe<String>;
  text_not_ends_with?: Maybe<String>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  AND?: Maybe<CommentScalarWhereInput[] | CommentScalarWhereInput>;
  OR?: Maybe<CommentScalarWhereInput[] | CommentScalarWhereInput>;
  NOT?: Maybe<CommentScalarWhereInput[] | CommentScalarWhereInput>;
}

export interface CommentUpdateManyWithWhereNestedInput {
  where: CommentScalarWhereInput;
  data: CommentUpdateManyDataInput;
}

export interface CommentUpdateManyDataInput {
  text?: Maybe<String>;
}

export interface RatingUpdateManyWithoutUserInput {
  create?: Maybe<RatingCreateWithoutUserInput[] | RatingCreateWithoutUserInput>;
  delete?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  set?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  disconnect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  update?: Maybe<
    | RatingUpdateWithWhereUniqueWithoutUserInput[]
    | RatingUpdateWithWhereUniqueWithoutUserInput
  >;
  upsert?: Maybe<
    | RatingUpsertWithWhereUniqueWithoutUserInput[]
    | RatingUpsertWithWhereUniqueWithoutUserInput
  >;
  deleteMany?: Maybe<RatingScalarWhereInput[] | RatingScalarWhereInput>;
  updateMany?: Maybe<
    | RatingUpdateManyWithWhereNestedInput[]
    | RatingUpdateManyWithWhereNestedInput
  >;
}

export interface RatingUpdateWithWhereUniqueWithoutUserInput {
  where: RatingWhereUniqueInput;
  data: RatingUpdateWithoutUserDataInput;
}

export interface RatingUpdateWithoutUserDataInput {
  value?: Maybe<Int>;
  comment?: Maybe<String>;
}

export interface RatingUpsertWithWhereUniqueWithoutUserInput {
  where: RatingWhereUniqueInput;
  update: RatingUpdateWithoutUserDataInput;
  create: RatingCreateWithoutUserInput;
}

export interface RatingScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  value?: Maybe<Int>;
  value_not?: Maybe<Int>;
  value_in?: Maybe<Int[] | Int>;
  value_not_in?: Maybe<Int[] | Int>;
  value_lt?: Maybe<Int>;
  value_lte?: Maybe<Int>;
  value_gt?: Maybe<Int>;
  value_gte?: Maybe<Int>;
  comment?: Maybe<String>;
  comment_not?: Maybe<String>;
  comment_in?: Maybe<String[] | String>;
  comment_not_in?: Maybe<String[] | String>;
  comment_lt?: Maybe<String>;
  comment_lte?: Maybe<String>;
  comment_gt?: Maybe<String>;
  comment_gte?: Maybe<String>;
  comment_contains?: Maybe<String>;
  comment_not_contains?: Maybe<String>;
  comment_starts_with?: Maybe<String>;
  comment_not_starts_with?: Maybe<String>;
  comment_ends_with?: Maybe<String>;
  comment_not_ends_with?: Maybe<String>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  AND?: Maybe<RatingScalarWhereInput[] | RatingScalarWhereInput>;
  OR?: Maybe<RatingScalarWhereInput[] | RatingScalarWhereInput>;
  NOT?: Maybe<RatingScalarWhereInput[] | RatingScalarWhereInput>;
}

export interface RatingUpdateManyWithWhereNestedInput {
  where: RatingScalarWhereInput;
  data: RatingUpdateManyDataInput;
}

export interface RatingUpdateManyDataInput {
  value?: Maybe<Int>;
  comment?: Maybe<String>;
}

export interface UserUpdatepermissionsInput {
  set?: Maybe<Permission[] | Permission>;
}

export interface UserUpdateinterestsInput {
  set?: Maybe<String[] | String>;
}

export interface UserUpsertNestedInput {
  update: UserUpdateDataInput;
  create: UserCreateInput;
}

export interface FileUpsertNestedInput {
  update: FileUpdateDataInput;
  create: FileCreateInput;
}

export interface LinkUpdateOneInput {
  create?: Maybe<LinkCreateInput>;
  update?: Maybe<LinkUpdateDataInput>;
  upsert?: Maybe<LinkUpsertNestedInput>;
  delete?: Maybe<Boolean>;
  disconnect?: Maybe<Boolean>;
  connect?: Maybe<LinkWhereUniqueInput>;
}

export interface LinkUpdateDataInput {
  url?: Maybe<String>;
  user?: Maybe<UserUpdateOneRequiredInput>;
  comment?: Maybe<String>;
  duration?: Maybe<Int>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface LinkUpsertNestedInput {
  update: LinkUpdateDataInput;
  create: LinkCreateInput;
}

export interface TrackUpsertWithWhereUniqueNestedInput {
  where: TrackWhereUniqueInput;
  update: TrackUpdateDataInput;
  create: TrackCreateInput;
}

export interface TrackScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  AND?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
  OR?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
  NOT?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
}

export interface TrackUpdateManyWithWhereNestedInput {
  where: TrackScalarWhereInput;
  data: TrackUpdateManyDataInput;
}

export interface TrackUpdateManyDataInput {
  order?: Maybe<Int>;
}

export interface VideoUpdateManyInput {
  create?: Maybe<VideoCreateInput[] | VideoCreateInput>;
  update?: Maybe<
    | VideoUpdateWithWhereUniqueNestedInput[]
    | VideoUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | VideoUpsertWithWhereUniqueNestedInput[]
    | VideoUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<VideoWhereUniqueInput[] | VideoWhereUniqueInput>;
  connect?: Maybe<VideoWhereUniqueInput[] | VideoWhereUniqueInput>;
  set?: Maybe<VideoWhereUniqueInput[] | VideoWhereUniqueInput>;
  disconnect?: Maybe<VideoWhereUniqueInput[] | VideoWhereUniqueInput>;
  deleteMany?: Maybe<VideoScalarWhereInput[] | VideoScalarWhereInput>;
  updateMany?: Maybe<
    VideoUpdateManyWithWhereNestedInput[] | VideoUpdateManyWithWhereNestedInput
  >;
}

export interface VideoUpdateWithWhereUniqueNestedInput {
  where: VideoWhereUniqueInput;
  data: VideoUpdateDataInput;
}

export interface VideoUpdateDataInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface VideoUpsertWithWhereUniqueNestedInput {
  where: VideoWhereUniqueInput;
  update: VideoUpdateDataInput;
  create: VideoCreateInput;
}

export interface VideoScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  AND?: Maybe<VideoScalarWhereInput[] | VideoScalarWhereInput>;
  OR?: Maybe<VideoScalarWhereInput[] | VideoScalarWhereInput>;
  NOT?: Maybe<VideoScalarWhereInput[] | VideoScalarWhereInput>;
}

export interface VideoUpdateManyWithWhereNestedInput {
  where: VideoScalarWhereInput;
  data: VideoUpdateManyDataInput;
}

export interface VideoUpdateManyDataInput {
  order?: Maybe<Int>;
}

export interface PictureUpdateManyInput {
  create?: Maybe<PictureCreateInput[] | PictureCreateInput>;
  update?: Maybe<
    | PictureUpdateWithWhereUniqueNestedInput[]
    | PictureUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | PictureUpsertWithWhereUniqueNestedInput[]
    | PictureUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<PictureWhereUniqueInput[] | PictureWhereUniqueInput>;
  connect?: Maybe<PictureWhereUniqueInput[] | PictureWhereUniqueInput>;
  set?: Maybe<PictureWhereUniqueInput[] | PictureWhereUniqueInput>;
  disconnect?: Maybe<PictureWhereUniqueInput[] | PictureWhereUniqueInput>;
  deleteMany?: Maybe<PictureScalarWhereInput[] | PictureScalarWhereInput>;
  updateMany?: Maybe<
    | PictureUpdateManyWithWhereNestedInput[]
    | PictureUpdateManyWithWhereNestedInput
  >;
}

export interface PictureUpdateWithWhereUniqueNestedInput {
  where: PictureWhereUniqueInput;
  data: PictureUpdateDataInput;
}

export interface PictureUpdateDataInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface PictureUpsertWithWhereUniqueNestedInput {
  where: PictureWhereUniqueInput;
  update: PictureUpdateDataInput;
  create: PictureCreateInput;
}

export interface PictureScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  updatedAt?: Maybe<DateTimeInput>;
  updatedAt_not?: Maybe<DateTimeInput>;
  updatedAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  updatedAt_lt?: Maybe<DateTimeInput>;
  updatedAt_lte?: Maybe<DateTimeInput>;
  updatedAt_gt?: Maybe<DateTimeInput>;
  updatedAt_gte?: Maybe<DateTimeInput>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  AND?: Maybe<PictureScalarWhereInput[] | PictureScalarWhereInput>;
  OR?: Maybe<PictureScalarWhereInput[] | PictureScalarWhereInput>;
  NOT?: Maybe<PictureScalarWhereInput[] | PictureScalarWhereInput>;
}

export interface PictureUpdateManyWithWhereNestedInput {
  where: PictureScalarWhereInput;
  data: PictureUpdateManyDataInput;
}

export interface PictureUpdateManyDataInput {
  order?: Maybe<Int>;
}

export interface BlockInstanceUpdateManyWithoutParentBlockInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutParentBlockInput[]
    | BlockInstanceCreateWithoutParentBlockInput
  >;
  delete?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  set?: Maybe<BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput>;
  disconnect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  update?: Maybe<
    | BlockInstanceUpdateWithWhereUniqueWithoutParentBlockInput[]
    | BlockInstanceUpdateWithWhereUniqueWithoutParentBlockInput
  >;
  upsert?: Maybe<
    | BlockInstanceUpsertWithWhereUniqueWithoutParentBlockInput[]
    | BlockInstanceUpsertWithWhereUniqueWithoutParentBlockInput
  >;
  deleteMany?: Maybe<
    BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput
  >;
  updateMany?: Maybe<
    | BlockInstanceUpdateManyWithWhereNestedInput[]
    | BlockInstanceUpdateManyWithWhereNestedInput
  >;
}

export interface BlockInstanceUpdateWithWhereUniqueWithoutParentBlockInput {
  where: BlockInstanceWhereUniqueInput;
  data: BlockInstanceUpdateWithoutParentBlockDataInput;
}

export interface BlockInstanceUpdateWithoutParentBlockDataInput {
  block?: Maybe<BlockUpdateOneRequiredWithoutParentBlockInstancesInput>;
  parentTraining?: Maybe<TrainingUpdateOneWithoutBlocksInput>;
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockUpdateOneRequiredWithoutParentBlockInstancesInput {
  create?: Maybe<BlockCreateWithoutParentBlockInstancesInput>;
  update?: Maybe<BlockUpdateWithoutParentBlockInstancesDataInput>;
  upsert?: Maybe<BlockUpsertWithoutParentBlockInstancesInput>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockUpdateWithoutParentBlockInstancesDataInput {
  title?: Maybe<String>;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format?: Maybe<FormatUpdateOneRequiredInput>;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackUpdateManyInput>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  blocks?: Maybe<BlockInstanceUpdateManyWithoutParentBlockInput>;
  exercises?: Maybe<ExerciseInstanceUpdateManyWithoutParentBlockInstancesInput>;
}

export interface ExerciseInstanceUpdateManyWithoutParentBlockInstancesInput {
  create?: Maybe<
    | ExerciseInstanceCreateWithoutParentBlockInstancesInput[]
    | ExerciseInstanceCreateWithoutParentBlockInstancesInput
  >;
  delete?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  connect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  set?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  disconnect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  update?: Maybe<
    | ExerciseInstanceUpdateWithWhereUniqueWithoutParentBlockInstancesInput[]
    | ExerciseInstanceUpdateWithWhereUniqueWithoutParentBlockInstancesInput
  >;
  upsert?: Maybe<
    | ExerciseInstanceUpsertWithWhereUniqueWithoutParentBlockInstancesInput[]
    | ExerciseInstanceUpsertWithWhereUniqueWithoutParentBlockInstancesInput
  >;
  deleteMany?: Maybe<
    ExerciseInstanceScalarWhereInput[] | ExerciseInstanceScalarWhereInput
  >;
  updateMany?: Maybe<
    | ExerciseInstanceUpdateManyWithWhereNestedInput[]
    | ExerciseInstanceUpdateManyWithWhereNestedInput
  >;
}

export interface ExerciseInstanceUpdateWithWhereUniqueWithoutParentBlockInstancesInput {
  where: ExerciseInstanceWhereUniqueInput;
  data: ExerciseInstanceUpdateWithoutParentBlockInstancesDataInput;
}

export interface ExerciseInstanceUpdateWithoutParentBlockInstancesDataInput {
  exercise?: Maybe<
    ExerciseUpdateOneRequiredWithoutParentExerciseInstancesInput
  >;
  order?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface ExerciseUpdateOneRequiredWithoutParentExerciseInstancesInput {
  create?: Maybe<ExerciseCreateWithoutParentExerciseInstancesInput>;
  update?: Maybe<ExerciseUpdateWithoutParentExerciseInstancesDataInput>;
  upsert?: Maybe<ExerciseUpsertWithoutParentExerciseInstancesInput>;
  connect?: Maybe<ExerciseWhereUniqueInput>;
}

export interface ExerciseUpdateWithoutParentExerciseInstancesDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
  baseExercise?: Maybe<ExerciseUpdatebaseExerciseInput>;
}

export interface ExerciseUpdatetargetsInput {
  set?: Maybe<String[] | String>;
}

export interface ExerciseUpdatebaseExerciseInput {
  set?: Maybe<String[] | String>;
}

export interface ExerciseUpsertWithoutParentExerciseInstancesInput {
  update: ExerciseUpdateWithoutParentExerciseInstancesDataInput;
  create: ExerciseCreateWithoutParentExerciseInstancesInput;
}

export interface ExerciseInstanceUpsertWithWhereUniqueWithoutParentBlockInstancesInput {
  where: ExerciseInstanceWhereUniqueInput;
  update: ExerciseInstanceUpdateWithoutParentBlockInstancesDataInput;
  create: ExerciseInstanceCreateWithoutParentBlockInstancesInput;
}

export interface ExerciseInstanceScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  repetitions_not?: Maybe<Int>;
  repetitions_in?: Maybe<Int[] | Int>;
  repetitions_not_in?: Maybe<Int[] | Int>;
  repetitions_lt?: Maybe<Int>;
  repetitions_lte?: Maybe<Int>;
  repetitions_gt?: Maybe<Int>;
  repetitions_gte?: Maybe<Int>;
  variation?: Maybe<String>;
  variation_not?: Maybe<String>;
  variation_in?: Maybe<String[] | String>;
  variation_not_in?: Maybe<String[] | String>;
  variation_lt?: Maybe<String>;
  variation_lte?: Maybe<String>;
  variation_gt?: Maybe<String>;
  variation_gte?: Maybe<String>;
  variation_contains?: Maybe<String>;
  variation_not_contains?: Maybe<String>;
  variation_starts_with?: Maybe<String>;
  variation_not_starts_with?: Maybe<String>;
  variation_ends_with?: Maybe<String>;
  variation_not_ends_with?: Maybe<String>;
  AND?: Maybe<
    ExerciseInstanceScalarWhereInput[] | ExerciseInstanceScalarWhereInput
  >;
  OR?: Maybe<
    ExerciseInstanceScalarWhereInput[] | ExerciseInstanceScalarWhereInput
  >;
  NOT?: Maybe<
    ExerciseInstanceScalarWhereInput[] | ExerciseInstanceScalarWhereInput
  >;
}

export interface ExerciseInstanceUpdateManyWithWhereNestedInput {
  where: ExerciseInstanceScalarWhereInput;
  data: ExerciseInstanceUpdateManyDataInput;
}

export interface ExerciseInstanceUpdateManyDataInput {
  order?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockUpsertWithoutParentBlockInstancesInput {
  update: BlockUpdateWithoutParentBlockInstancesDataInput;
  create: BlockCreateWithoutParentBlockInstancesInput;
}

export interface TrainingUpdateOneWithoutBlocksInput {
  create?: Maybe<TrainingCreateWithoutBlocksInput>;
  update?: Maybe<TrainingUpdateWithoutBlocksDataInput>;
  upsert?: Maybe<TrainingUpsertWithoutBlocksInput>;
  delete?: Maybe<Boolean>;
  disconnect?: Maybe<Boolean>;
  connect?: Maybe<TrainingWhereUniqueInput>;
}

export interface TrainingUpdateWithoutBlocksDataInput {
  title?: Maybe<String>;
  type?: Maybe<TrainingTypeUpdateOneRequiredInput>;
  trainingDate?: Maybe<DateTimeInput>;
  location?: Maybe<String>;
  registrations?: Maybe<UserUpdateManyInput>;
  attendance?: Maybe<Int>;
  ratings?: Maybe<RatingUpdateManyInput>;
  published?: Maybe<Boolean>;
}

export interface TrainingTypeUpdateOneRequiredInput {
  create?: Maybe<TrainingTypeCreateInput>;
  update?: Maybe<TrainingTypeUpdateDataInput>;
  upsert?: Maybe<TrainingTypeUpsertNestedInput>;
  connect?: Maybe<TrainingTypeWhereUniqueInput>;
}

export interface TrainingTypeUpdateDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface TrainingTypeUpsertNestedInput {
  update: TrainingTypeUpdateDataInput;
  create: TrainingTypeCreateInput;
}

export interface UserUpdateManyInput {
  create?: Maybe<UserCreateInput[] | UserCreateInput>;
  update?: Maybe<
    | UserUpdateWithWhereUniqueNestedInput[]
    | UserUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | UserUpsertWithWhereUniqueNestedInput[]
    | UserUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<UserWhereUniqueInput[] | UserWhereUniqueInput>;
  connect?: Maybe<UserWhereUniqueInput[] | UserWhereUniqueInput>;
  set?: Maybe<UserWhereUniqueInput[] | UserWhereUniqueInput>;
  disconnect?: Maybe<UserWhereUniqueInput[] | UserWhereUniqueInput>;
  deleteMany?: Maybe<UserScalarWhereInput[] | UserScalarWhereInput>;
  updateMany?: Maybe<
    UserUpdateManyWithWhereNestedInput[] | UserUpdateManyWithWhereNestedInput
  >;
}

export interface UserUpdateWithWhereUniqueNestedInput {
  where: UserWhereUniqueInput;
  data: UserUpdateDataInput;
}

export interface UserUpsertWithWhereUniqueNestedInput {
  where: UserWhereUniqueInput;
  update: UserUpdateDataInput;
  create: UserCreateInput;
}

export interface UserScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  email?: Maybe<String>;
  email_not?: Maybe<String>;
  email_in?: Maybe<String[] | String>;
  email_not_in?: Maybe<String[] | String>;
  email_lt?: Maybe<String>;
  email_lte?: Maybe<String>;
  email_gt?: Maybe<String>;
  email_gte?: Maybe<String>;
  email_contains?: Maybe<String>;
  email_not_contains?: Maybe<String>;
  email_starts_with?: Maybe<String>;
  email_not_starts_with?: Maybe<String>;
  email_ends_with?: Maybe<String>;
  email_not_ends_with?: Maybe<String>;
  name?: Maybe<String>;
  name_not?: Maybe<String>;
  name_in?: Maybe<String[] | String>;
  name_not_in?: Maybe<String[] | String>;
  name_lt?: Maybe<String>;
  name_lte?: Maybe<String>;
  name_gt?: Maybe<String>;
  name_gte?: Maybe<String>;
  name_contains?: Maybe<String>;
  name_not_contains?: Maybe<String>;
  name_starts_with?: Maybe<String>;
  name_not_starts_with?: Maybe<String>;
  name_ends_with?: Maybe<String>;
  name_not_ends_with?: Maybe<String>;
  password?: Maybe<String>;
  password_not?: Maybe<String>;
  password_in?: Maybe<String[] | String>;
  password_not_in?: Maybe<String[] | String>;
  password_lt?: Maybe<String>;
  password_lte?: Maybe<String>;
  password_gt?: Maybe<String>;
  password_gte?: Maybe<String>;
  password_contains?: Maybe<String>;
  password_not_contains?: Maybe<String>;
  password_starts_with?: Maybe<String>;
  password_not_starts_with?: Maybe<String>;
  password_ends_with?: Maybe<String>;
  password_not_ends_with?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetToken_not?: Maybe<String>;
  resetToken_in?: Maybe<String[] | String>;
  resetToken_not_in?: Maybe<String[] | String>;
  resetToken_lt?: Maybe<String>;
  resetToken_lte?: Maybe<String>;
  resetToken_gt?: Maybe<String>;
  resetToken_gte?: Maybe<String>;
  resetToken_contains?: Maybe<String>;
  resetToken_not_contains?: Maybe<String>;
  resetToken_starts_with?: Maybe<String>;
  resetToken_not_starts_with?: Maybe<String>;
  resetToken_ends_with?: Maybe<String>;
  resetToken_not_ends_with?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  resetTokenExpiry_not?: Maybe<Float>;
  resetTokenExpiry_in?: Maybe<Float[] | Float>;
  resetTokenExpiry_not_in?: Maybe<Float[] | Float>;
  resetTokenExpiry_lt?: Maybe<Float>;
  resetTokenExpiry_lte?: Maybe<Float>;
  resetTokenExpiry_gt?: Maybe<Float>;
  resetTokenExpiry_gte?: Maybe<Float>;
  createdAt?: Maybe<DateTimeInput>;
  createdAt_not?: Maybe<DateTimeInput>;
  createdAt_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_not_in?: Maybe<DateTimeInput[] | DateTimeInput>;
  createdAt_lt?: Maybe<DateTimeInput>;
  createdAt_lte?: Maybe<DateTimeInput>;
  createdAt_gt?: Maybe<DateTimeInput>;
  createdAt_gte?: Maybe<DateTimeInput>;
  AND?: Maybe<UserScalarWhereInput[] | UserScalarWhereInput>;
  OR?: Maybe<UserScalarWhereInput[] | UserScalarWhereInput>;
  NOT?: Maybe<UserScalarWhereInput[] | UserScalarWhereInput>;
}

export interface UserUpdateManyWithWhereNestedInput {
  where: UserScalarWhereInput;
  data: UserUpdateManyDataInput;
}

export interface UserUpdateManyDataInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface RatingUpdateManyInput {
  create?: Maybe<RatingCreateInput[] | RatingCreateInput>;
  update?: Maybe<
    | RatingUpdateWithWhereUniqueNestedInput[]
    | RatingUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | RatingUpsertWithWhereUniqueNestedInput[]
    | RatingUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  set?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  disconnect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
  deleteMany?: Maybe<RatingScalarWhereInput[] | RatingScalarWhereInput>;
  updateMany?: Maybe<
    | RatingUpdateManyWithWhereNestedInput[]
    | RatingUpdateManyWithWhereNestedInput
  >;
}

export interface RatingUpdateWithWhereUniqueNestedInput {
  where: RatingWhereUniqueInput;
  data: RatingUpdateDataInput;
}

export interface RatingUpdateDataInput {
  user?: Maybe<UserUpdateOneRequiredWithoutRatingsInput>;
  value?: Maybe<Int>;
  comment?: Maybe<String>;
}

export interface UserUpdateOneRequiredWithoutRatingsInput {
  create?: Maybe<UserCreateWithoutRatingsInput>;
  update?: Maybe<UserUpdateWithoutRatingsDataInput>;
  upsert?: Maybe<UserUpsertWithoutRatingsInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserUpdateWithoutRatingsDataInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface UserUpsertWithoutRatingsInput {
  update: UserUpdateWithoutRatingsDataInput;
  create: UserCreateWithoutRatingsInput;
}

export interface RatingUpsertWithWhereUniqueNestedInput {
  where: RatingWhereUniqueInput;
  update: RatingUpdateDataInput;
  create: RatingCreateInput;
}

export interface TrainingUpsertWithoutBlocksInput {
  update: TrainingUpdateWithoutBlocksDataInput;
  create: TrainingCreateWithoutBlocksInput;
}

export interface BlockInstanceUpsertWithWhereUniqueWithoutParentBlockInput {
  where: BlockInstanceWhereUniqueInput;
  update: BlockInstanceUpdateWithoutParentBlockDataInput;
  create: BlockInstanceCreateWithoutParentBlockInput;
}

export interface BlockInstanceScalarWhereInput {
  id?: Maybe<ID_Input>;
  id_not?: Maybe<ID_Input>;
  id_in?: Maybe<ID_Input[] | ID_Input>;
  id_not_in?: Maybe<ID_Input[] | ID_Input>;
  id_lt?: Maybe<ID_Input>;
  id_lte?: Maybe<ID_Input>;
  id_gt?: Maybe<ID_Input>;
  id_gte?: Maybe<ID_Input>;
  id_contains?: Maybe<ID_Input>;
  id_not_contains?: Maybe<ID_Input>;
  id_starts_with?: Maybe<ID_Input>;
  id_not_starts_with?: Maybe<ID_Input>;
  id_ends_with?: Maybe<ID_Input>;
  id_not_ends_with?: Maybe<ID_Input>;
  order?: Maybe<Int>;
  order_not?: Maybe<Int>;
  order_in?: Maybe<Int[] | Int>;
  order_not_in?: Maybe<Int[] | Int>;
  order_lt?: Maybe<Int>;
  order_lte?: Maybe<Int>;
  order_gt?: Maybe<Int>;
  order_gte?: Maybe<Int>;
  rounds?: Maybe<Int>;
  rounds_not?: Maybe<Int>;
  rounds_in?: Maybe<Int[] | Int>;
  rounds_not_in?: Maybe<Int[] | Int>;
  rounds_lt?: Maybe<Int>;
  rounds_lte?: Maybe<Int>;
  rounds_gt?: Maybe<Int>;
  rounds_gte?: Maybe<Int>;
  variation?: Maybe<String>;
  variation_not?: Maybe<String>;
  variation_in?: Maybe<String[] | String>;
  variation_not_in?: Maybe<String[] | String>;
  variation_lt?: Maybe<String>;
  variation_lte?: Maybe<String>;
  variation_gt?: Maybe<String>;
  variation_gte?: Maybe<String>;
  variation_contains?: Maybe<String>;
  variation_not_contains?: Maybe<String>;
  variation_starts_with?: Maybe<String>;
  variation_not_starts_with?: Maybe<String>;
  variation_ends_with?: Maybe<String>;
  variation_not_ends_with?: Maybe<String>;
  AND?: Maybe<BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput>;
  OR?: Maybe<BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput>;
  NOT?: Maybe<BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput>;
}

export interface BlockInstanceUpdateManyWithWhereNestedInput {
  where: BlockInstanceScalarWhereInput;
  data: BlockInstanceUpdateManyDataInput;
}

export interface BlockInstanceUpdateManyDataInput {
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockInstanceUpdateManyWithoutBlockInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutBlockInput[]
    | BlockInstanceCreateWithoutBlockInput
  >;
  delete?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  set?: Maybe<BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput>;
  disconnect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  update?: Maybe<
    | BlockInstanceUpdateWithWhereUniqueWithoutBlockInput[]
    | BlockInstanceUpdateWithWhereUniqueWithoutBlockInput
  >;
  upsert?: Maybe<
    | BlockInstanceUpsertWithWhereUniqueWithoutBlockInput[]
    | BlockInstanceUpsertWithWhereUniqueWithoutBlockInput
  >;
  deleteMany?: Maybe<
    BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput
  >;
  updateMany?: Maybe<
    | BlockInstanceUpdateManyWithWhereNestedInput[]
    | BlockInstanceUpdateManyWithWhereNestedInput
  >;
}

export interface BlockInstanceUpdateWithWhereUniqueWithoutBlockInput {
  where: BlockInstanceWhereUniqueInput;
  data: BlockInstanceUpdateWithoutBlockDataInput;
}

export interface BlockInstanceUpdateWithoutBlockDataInput {
  parentBlock?: Maybe<BlockUpdateOneWithoutBlocksInput>;
  parentTraining?: Maybe<TrainingUpdateOneWithoutBlocksInput>;
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockUpdateOneWithoutBlocksInput {
  create?: Maybe<BlockCreateWithoutBlocksInput>;
  update?: Maybe<BlockUpdateWithoutBlocksDataInput>;
  upsert?: Maybe<BlockUpsertWithoutBlocksInput>;
  delete?: Maybe<Boolean>;
  disconnect?: Maybe<Boolean>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockUpdateWithoutBlocksDataInput {
  title?: Maybe<String>;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format?: Maybe<FormatUpdateOneRequiredInput>;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackUpdateManyInput>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  parentBlockInstances?: Maybe<BlockInstanceUpdateManyWithoutBlockInput>;
  exercises?: Maybe<ExerciseInstanceUpdateManyWithoutParentBlockInstancesInput>;
}

export interface BlockUpsertWithoutBlocksInput {
  update: BlockUpdateWithoutBlocksDataInput;
  create: BlockCreateWithoutBlocksInput;
}

export interface BlockInstanceUpsertWithWhereUniqueWithoutBlockInput {
  where: BlockInstanceWhereUniqueInput;
  update: BlockInstanceUpdateWithoutBlockDataInput;
  create: BlockInstanceCreateWithoutBlockInput;
}

export interface BlockUpdateManyMutationInput {
  title?: Maybe<String>;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  rest?: Maybe<Int>;
}

export interface BlockInstanceCreateInput {
  id?: Maybe<ID_Input>;
  block: BlockCreateOneWithoutParentBlockInstancesInput;
  parentBlock?: Maybe<BlockCreateOneWithoutBlocksInput>;
  parentTraining?: Maybe<TrainingCreateOneWithoutBlocksInput>;
  order: Int;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockInstanceUpdateInput {
  block?: Maybe<BlockUpdateOneRequiredWithoutParentBlockInstancesInput>;
  parentBlock?: Maybe<BlockUpdateOneWithoutBlocksInput>;
  parentTraining?: Maybe<TrainingUpdateOneWithoutBlocksInput>;
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockInstanceUpdateManyMutationInput {
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface CommentCreateInput {
  id?: Maybe<ID_Input>;
  text: String;
  author: UserCreateOneWithoutCommentsInput;
}

export interface UserCreateOneWithoutCommentsInput {
  create?: Maybe<UserCreateWithoutCommentsInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserCreateWithoutCommentsInput {
  id?: Maybe<ID_Input>;
  email: String;
  name: String;
  password: String;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  ratings?: Maybe<RatingCreateManyWithoutUserInput>;
  permissions?: Maybe<UserCreatepermissionsInput>;
  interests?: Maybe<UserCreateinterestsInput>;
}

export interface CommentUpdateInput {
  text?: Maybe<String>;
  author?: Maybe<UserUpdateOneRequiredWithoutCommentsInput>;
}

export interface UserUpdateOneRequiredWithoutCommentsInput {
  create?: Maybe<UserCreateWithoutCommentsInput>;
  update?: Maybe<UserUpdateWithoutCommentsDataInput>;
  upsert?: Maybe<UserUpsertWithoutCommentsInput>;
  connect?: Maybe<UserWhereUniqueInput>;
}

export interface UserUpdateWithoutCommentsDataInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface UserUpsertWithoutCommentsInput {
  update: UserUpdateWithoutCommentsDataInput;
  create: UserCreateWithoutCommentsInput;
}

export interface CommentUpdateManyMutationInput {
  text?: Maybe<String>;
}

export interface ExerciseCreateInput {
  id?: Maybe<ID_Input>;
  name: String;
  description?: Maybe<String>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  targets?: Maybe<ExerciseCreatetargetsInput>;
  baseExercise?: Maybe<ExerciseCreatebaseExerciseInput>;
  parentExerciseInstances?: Maybe<
    ExerciseInstanceCreateManyWithoutExerciseInput
  >;
}

export interface ExerciseInstanceCreateManyWithoutExerciseInput {
  create?: Maybe<
    | ExerciseInstanceCreateWithoutExerciseInput[]
    | ExerciseInstanceCreateWithoutExerciseInput
  >;
  connect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
}

export interface ExerciseInstanceCreateWithoutExerciseInput {
  id?: Maybe<ID_Input>;
  order: Int;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
  parentBlockInstances: BlockCreateOneWithoutExercisesInput;
}

export interface BlockCreateOneWithoutExercisesInput {
  create?: Maybe<BlockCreateWithoutExercisesInput>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockCreateWithoutExercisesInput {
  id?: Maybe<ID_Input>;
  title: String;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format: FormatCreateOneInput;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackCreateManyInput>;
  videos?: Maybe<VideoCreateManyInput>;
  pictures?: Maybe<PictureCreateManyInput>;
  blocks?: Maybe<BlockInstanceCreateManyWithoutParentBlockInput>;
  parentBlockInstances?: Maybe<BlockInstanceCreateManyWithoutBlockInput>;
}

export interface ExerciseUpdateInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
  baseExercise?: Maybe<ExerciseUpdatebaseExerciseInput>;
  parentExerciseInstances?: Maybe<
    ExerciseInstanceUpdateManyWithoutExerciseInput
  >;
}

export interface ExerciseInstanceUpdateManyWithoutExerciseInput {
  create?: Maybe<
    | ExerciseInstanceCreateWithoutExerciseInput[]
    | ExerciseInstanceCreateWithoutExerciseInput
  >;
  delete?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  connect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  set?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  disconnect?: Maybe<
    ExerciseInstanceWhereUniqueInput[] | ExerciseInstanceWhereUniqueInput
  >;
  update?: Maybe<
    | ExerciseInstanceUpdateWithWhereUniqueWithoutExerciseInput[]
    | ExerciseInstanceUpdateWithWhereUniqueWithoutExerciseInput
  >;
  upsert?: Maybe<
    | ExerciseInstanceUpsertWithWhereUniqueWithoutExerciseInput[]
    | ExerciseInstanceUpsertWithWhereUniqueWithoutExerciseInput
  >;
  deleteMany?: Maybe<
    ExerciseInstanceScalarWhereInput[] | ExerciseInstanceScalarWhereInput
  >;
  updateMany?: Maybe<
    | ExerciseInstanceUpdateManyWithWhereNestedInput[]
    | ExerciseInstanceUpdateManyWithWhereNestedInput
  >;
}

export interface ExerciseInstanceUpdateWithWhereUniqueWithoutExerciseInput {
  where: ExerciseInstanceWhereUniqueInput;
  data: ExerciseInstanceUpdateWithoutExerciseDataInput;
}

export interface ExerciseInstanceUpdateWithoutExerciseDataInput {
  order?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
  parentBlockInstances?: Maybe<BlockUpdateOneRequiredWithoutExercisesInput>;
}

export interface BlockUpdateOneRequiredWithoutExercisesInput {
  create?: Maybe<BlockCreateWithoutExercisesInput>;
  update?: Maybe<BlockUpdateWithoutExercisesDataInput>;
  upsert?: Maybe<BlockUpsertWithoutExercisesInput>;
  connect?: Maybe<BlockWhereUniqueInput>;
}

export interface BlockUpdateWithoutExercisesDataInput {
  title?: Maybe<String>;
  description?: Maybe<String>;
  duration?: Maybe<Int>;
  format?: Maybe<FormatUpdateOneRequiredInput>;
  rest?: Maybe<Int>;
  tracks?: Maybe<TrackUpdateManyInput>;
  videos?: Maybe<VideoUpdateManyInput>;
  pictures?: Maybe<PictureUpdateManyInput>;
  blocks?: Maybe<BlockInstanceUpdateManyWithoutParentBlockInput>;
  parentBlockInstances?: Maybe<BlockInstanceUpdateManyWithoutBlockInput>;
}

export interface BlockUpsertWithoutExercisesInput {
  update: BlockUpdateWithoutExercisesDataInput;
  create: BlockCreateWithoutExercisesInput;
}

export interface ExerciseInstanceUpsertWithWhereUniqueWithoutExerciseInput {
  where: ExerciseInstanceWhereUniqueInput;
  update: ExerciseInstanceUpdateWithoutExerciseDataInput;
  create: ExerciseInstanceCreateWithoutExerciseInput;
}

export interface ExerciseUpdateManyMutationInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
  baseExercise?: Maybe<ExerciseUpdatebaseExerciseInput>;
}

export interface ExerciseInstanceCreateInput {
  id?: Maybe<ID_Input>;
  exercise: ExerciseCreateOneWithoutParentExerciseInstancesInput;
  order: Int;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
  parentBlockInstances: BlockCreateOneWithoutExercisesInput;
}

export interface ExerciseInstanceUpdateInput {
  exercise?: Maybe<
    ExerciseUpdateOneRequiredWithoutParentExerciseInstancesInput
  >;
  order?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
  parentBlockInstances?: Maybe<BlockUpdateOneRequiredWithoutExercisesInput>;
}

export interface ExerciseInstanceUpdateManyMutationInput {
  order?: Maybe<Int>;
  repetitions?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface FileUpdateInput {
  user?: Maybe<UserUpdateOneRequiredInput>;
  path?: Maybe<String>;
  comment?: Maybe<String>;
  mimetype?: Maybe<String>;
  thumbnail?: Maybe<String>;
  filename?: Maybe<String>;
  encoding?: Maybe<String>;
  size?: Maybe<Int>;
  width?: Maybe<Int>;
  height?: Maybe<Int>;
  duration?: Maybe<Float>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface FileUpdateManyMutationInput {
  path?: Maybe<String>;
  comment?: Maybe<String>;
  mimetype?: Maybe<String>;
  thumbnail?: Maybe<String>;
  filename?: Maybe<String>;
  encoding?: Maybe<String>;
  size?: Maybe<Int>;
  width?: Maybe<Int>;
  height?: Maybe<Int>;
  duration?: Maybe<Float>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface FormatUpdateInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface FormatUpdateManyMutationInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface LinkUpdateInput {
  url?: Maybe<String>;
  user?: Maybe<UserUpdateOneRequiredInput>;
  comment?: Maybe<String>;
  duration?: Maybe<Int>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface LinkUpdateManyMutationInput {
  url?: Maybe<String>;
  comment?: Maybe<String>;
  duration?: Maybe<Int>;
  title?: Maybe<String>;
  artist?: Maybe<String>;
}

export interface PictureUpdateInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface PictureUpdateManyMutationInput {
  order?: Maybe<Int>;
}

export interface RatingUpdateInput {
  user?: Maybe<UserUpdateOneRequiredWithoutRatingsInput>;
  value?: Maybe<Int>;
  comment?: Maybe<String>;
}

export interface RatingUpdateManyMutationInput {
  value?: Maybe<Int>;
  comment?: Maybe<String>;
}

export interface TrackUpdateInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface TrackUpdateManyMutationInput {
  order?: Maybe<Int>;
}

export interface TrainingCreateInput {
  id?: Maybe<ID_Input>;
  title: String;
  type: TrainingTypeCreateOneInput;
  trainingDate: DateTimeInput;
  location: String;
  registrations?: Maybe<UserCreateManyInput>;
  attendance?: Maybe<Int>;
  ratings?: Maybe<RatingCreateManyInput>;
  published: Boolean;
  blocks?: Maybe<BlockInstanceCreateManyWithoutParentTrainingInput>;
}

export interface BlockInstanceCreateManyWithoutParentTrainingInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutParentTrainingInput[]
    | BlockInstanceCreateWithoutParentTrainingInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
}

export interface BlockInstanceCreateWithoutParentTrainingInput {
  id?: Maybe<ID_Input>;
  block: BlockCreateOneWithoutParentBlockInstancesInput;
  parentBlock?: Maybe<BlockCreateOneWithoutBlocksInput>;
  order: Int;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface TrainingUpdateInput {
  title?: Maybe<String>;
  type?: Maybe<TrainingTypeUpdateOneRequiredInput>;
  trainingDate?: Maybe<DateTimeInput>;
  location?: Maybe<String>;
  registrations?: Maybe<UserUpdateManyInput>;
  attendance?: Maybe<Int>;
  ratings?: Maybe<RatingUpdateManyInput>;
  published?: Maybe<Boolean>;
  blocks?: Maybe<BlockInstanceUpdateManyWithoutParentTrainingInput>;
}

export interface BlockInstanceUpdateManyWithoutParentTrainingInput {
  create?: Maybe<
    | BlockInstanceCreateWithoutParentTrainingInput[]
    | BlockInstanceCreateWithoutParentTrainingInput
  >;
  delete?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  connect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  set?: Maybe<BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput>;
  disconnect?: Maybe<
    BlockInstanceWhereUniqueInput[] | BlockInstanceWhereUniqueInput
  >;
  update?: Maybe<
    | BlockInstanceUpdateWithWhereUniqueWithoutParentTrainingInput[]
    | BlockInstanceUpdateWithWhereUniqueWithoutParentTrainingInput
  >;
  upsert?: Maybe<
    | BlockInstanceUpsertWithWhereUniqueWithoutParentTrainingInput[]
    | BlockInstanceUpsertWithWhereUniqueWithoutParentTrainingInput
  >;
  deleteMany?: Maybe<
    BlockInstanceScalarWhereInput[] | BlockInstanceScalarWhereInput
  >;
  updateMany?: Maybe<
    | BlockInstanceUpdateManyWithWhereNestedInput[]
    | BlockInstanceUpdateManyWithWhereNestedInput
  >;
}

export interface BlockInstanceUpdateWithWhereUniqueWithoutParentTrainingInput {
  where: BlockInstanceWhereUniqueInput;
  data: BlockInstanceUpdateWithoutParentTrainingDataInput;
}

export interface BlockInstanceUpdateWithoutParentTrainingDataInput {
  block?: Maybe<BlockUpdateOneRequiredWithoutParentBlockInstancesInput>;
  parentBlock?: Maybe<BlockUpdateOneWithoutBlocksInput>;
  order?: Maybe<Int>;
  rounds?: Maybe<Int>;
  variation?: Maybe<String>;
}

export interface BlockInstanceUpsertWithWhereUniqueWithoutParentTrainingInput {
  where: BlockInstanceWhereUniqueInput;
  update: BlockInstanceUpdateWithoutParentTrainingDataInput;
  create: BlockInstanceCreateWithoutParentTrainingInput;
}

export interface TrainingUpdateManyMutationInput {
  title?: Maybe<String>;
  trainingDate?: Maybe<DateTimeInput>;
  location?: Maybe<String>;
  attendance?: Maybe<Int>;
  published?: Maybe<Boolean>;
}

export interface TrainingTypeUpdateInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface TrainingTypeUpdateManyMutationInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
}

export interface UserUpdateInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface UserUpdateManyMutationInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  resetToken?: Maybe<String>;
  resetTokenExpiry?: Maybe<Float>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

export interface VideoUpdateInput {
  order?: Maybe<Int>;
  file?: Maybe<FileUpdateOneInput>;
  link?: Maybe<LinkUpdateOneInput>;
}

export interface VideoUpdateManyMutationInput {
  order?: Maybe<Int>;
}

export interface BlockSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<BlockWhereInput>;
  AND?: Maybe<BlockSubscriptionWhereInput[] | BlockSubscriptionWhereInput>;
  OR?: Maybe<BlockSubscriptionWhereInput[] | BlockSubscriptionWhereInput>;
  NOT?: Maybe<BlockSubscriptionWhereInput[] | BlockSubscriptionWhereInput>;
}

export interface BlockInstanceSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<BlockInstanceWhereInput>;
  AND?: Maybe<
    BlockInstanceSubscriptionWhereInput[] | BlockInstanceSubscriptionWhereInput
  >;
  OR?: Maybe<
    BlockInstanceSubscriptionWhereInput[] | BlockInstanceSubscriptionWhereInput
  >;
  NOT?: Maybe<
    BlockInstanceSubscriptionWhereInput[] | BlockInstanceSubscriptionWhereInput
  >;
}

export interface CommentSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<CommentWhereInput>;
  AND?: Maybe<CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput>;
  OR?: Maybe<CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput>;
  NOT?: Maybe<CommentSubscriptionWhereInput[] | CommentSubscriptionWhereInput>;
}

export interface ExerciseSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<ExerciseWhereInput>;
  AND?: Maybe<
    ExerciseSubscriptionWhereInput[] | ExerciseSubscriptionWhereInput
  >;
  OR?: Maybe<ExerciseSubscriptionWhereInput[] | ExerciseSubscriptionWhereInput>;
  NOT?: Maybe<
    ExerciseSubscriptionWhereInput[] | ExerciseSubscriptionWhereInput
  >;
}

export interface ExerciseInstanceSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<ExerciseInstanceWhereInput>;
  AND?: Maybe<
    | ExerciseInstanceSubscriptionWhereInput[]
    | ExerciseInstanceSubscriptionWhereInput
  >;
  OR?: Maybe<
    | ExerciseInstanceSubscriptionWhereInput[]
    | ExerciseInstanceSubscriptionWhereInput
  >;
  NOT?: Maybe<
    | ExerciseInstanceSubscriptionWhereInput[]
    | ExerciseInstanceSubscriptionWhereInput
  >;
}

export interface FileSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<FileWhereInput>;
  AND?: Maybe<FileSubscriptionWhereInput[] | FileSubscriptionWhereInput>;
  OR?: Maybe<FileSubscriptionWhereInput[] | FileSubscriptionWhereInput>;
  NOT?: Maybe<FileSubscriptionWhereInput[] | FileSubscriptionWhereInput>;
}

export interface FormatSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<FormatWhereInput>;
  AND?: Maybe<FormatSubscriptionWhereInput[] | FormatSubscriptionWhereInput>;
  OR?: Maybe<FormatSubscriptionWhereInput[] | FormatSubscriptionWhereInput>;
  NOT?: Maybe<FormatSubscriptionWhereInput[] | FormatSubscriptionWhereInput>;
}

export interface LinkSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<LinkWhereInput>;
  AND?: Maybe<LinkSubscriptionWhereInput[] | LinkSubscriptionWhereInput>;
  OR?: Maybe<LinkSubscriptionWhereInput[] | LinkSubscriptionWhereInput>;
  NOT?: Maybe<LinkSubscriptionWhereInput[] | LinkSubscriptionWhereInput>;
}

export interface PictureSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<PictureWhereInput>;
  AND?: Maybe<PictureSubscriptionWhereInput[] | PictureSubscriptionWhereInput>;
  OR?: Maybe<PictureSubscriptionWhereInput[] | PictureSubscriptionWhereInput>;
  NOT?: Maybe<PictureSubscriptionWhereInput[] | PictureSubscriptionWhereInput>;
}

export interface RatingSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<RatingWhereInput>;
  AND?: Maybe<RatingSubscriptionWhereInput[] | RatingSubscriptionWhereInput>;
  OR?: Maybe<RatingSubscriptionWhereInput[] | RatingSubscriptionWhereInput>;
  NOT?: Maybe<RatingSubscriptionWhereInput[] | RatingSubscriptionWhereInput>;
}

export interface TrackSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<TrackWhereInput>;
  AND?: Maybe<TrackSubscriptionWhereInput[] | TrackSubscriptionWhereInput>;
  OR?: Maybe<TrackSubscriptionWhereInput[] | TrackSubscriptionWhereInput>;
  NOT?: Maybe<TrackSubscriptionWhereInput[] | TrackSubscriptionWhereInput>;
}

export interface TrainingSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<TrainingWhereInput>;
  AND?: Maybe<
    TrainingSubscriptionWhereInput[] | TrainingSubscriptionWhereInput
  >;
  OR?: Maybe<TrainingSubscriptionWhereInput[] | TrainingSubscriptionWhereInput>;
  NOT?: Maybe<
    TrainingSubscriptionWhereInput[] | TrainingSubscriptionWhereInput
  >;
}

export interface TrainingTypeSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<TrainingTypeWhereInput>;
  AND?: Maybe<
    TrainingTypeSubscriptionWhereInput[] | TrainingTypeSubscriptionWhereInput
  >;
  OR?: Maybe<
    TrainingTypeSubscriptionWhereInput[] | TrainingTypeSubscriptionWhereInput
  >;
  NOT?: Maybe<
    TrainingTypeSubscriptionWhereInput[] | TrainingTypeSubscriptionWhereInput
  >;
}

export interface UserSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<UserWhereInput>;
  AND?: Maybe<UserSubscriptionWhereInput[] | UserSubscriptionWhereInput>;
  OR?: Maybe<UserSubscriptionWhereInput[] | UserSubscriptionWhereInput>;
  NOT?: Maybe<UserSubscriptionWhereInput[] | UserSubscriptionWhereInput>;
}

export interface VideoSubscriptionWhereInput {
  mutation_in?: Maybe<MutationType[] | MutationType>;
  updatedFields_contains?: Maybe<String>;
  updatedFields_contains_every?: Maybe<String[] | String>;
  updatedFields_contains_some?: Maybe<String[] | String>;
  node?: Maybe<VideoWhereInput>;
  AND?: Maybe<VideoSubscriptionWhereInput[] | VideoSubscriptionWhereInput>;
  OR?: Maybe<VideoSubscriptionWhereInput[] | VideoSubscriptionWhereInput>;
  NOT?: Maybe<VideoSubscriptionWhereInput[] | VideoSubscriptionWhereInput>;
}

export interface NodeNode {
  id: ID_Output;
}

export interface Block {
  id: ID_Output;
  title: String;
  description?: String;
  duration?: Int;
  rest?: Int;
}

export interface BlockPromise extends Promise<Block>, Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  description: () => Promise<String>;
  duration: () => Promise<Int>;
  format: <T = FormatPromise>() => T;
  rest: () => Promise<Int>;
  tracks: <T = FragmentableArray<Track>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  videos: <T = FragmentableArray<Video>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = FragmentableArray<Picture>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  blocks: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  parentBlockInstances: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = FragmentableArray<ExerciseInstance>>(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface BlockSubscription
  extends Promise<AsyncIterator<Block>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  format: <T = FormatSubscription>() => T;
  rest: () => Promise<AsyncIterator<Int>>;
  tracks: <T = Promise<AsyncIterator<TrackSubscription>>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  videos: <T = Promise<AsyncIterator<VideoSubscription>>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = Promise<AsyncIterator<PictureSubscription>>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  blocks: <T = Promise<AsyncIterator<BlockInstanceSubscription>>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  parentBlockInstances: <
    T = Promise<AsyncIterator<BlockInstanceSubscription>>
  >(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = Promise<AsyncIterator<ExerciseInstanceSubscription>>>(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface BlockNullablePromise
  extends Promise<Block | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  description: () => Promise<String>;
  duration: () => Promise<Int>;
  format: <T = FormatPromise>() => T;
  rest: () => Promise<Int>;
  tracks: <T = FragmentableArray<Track>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  videos: <T = FragmentableArray<Video>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = FragmentableArray<Picture>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  blocks: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  parentBlockInstances: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = FragmentableArray<ExerciseInstance>>(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface Format {
  id: ID_Output;
  name: String;
  description: String;
}

export interface FormatPromise extends Promise<Format>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface FormatSubscription
  extends Promise<AsyncIterator<Format>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface FormatNullablePromise
  extends Promise<Format | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface Track {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface TrackPromise extends Promise<Track>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface TrackSubscription
  extends Promise<AsyncIterator<Track>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
  file: <T = FileSubscription>() => T;
  link: <T = LinkSubscription>() => T;
}

export interface TrackNullablePromise
  extends Promise<Track | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface File {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  path: String;
  comment?: String;
  mimetype?: String;
  thumbnail?: String;
  filename?: String;
  encoding?: String;
  size?: Int;
  width?: Int;
  height?: Int;
  duration?: Float;
  title?: String;
  artist?: String;
}

export interface FilePromise extends Promise<File>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  user: <T = UserPromise>() => T;
  path: () => Promise<String>;
  comment: () => Promise<String>;
  mimetype: () => Promise<String>;
  thumbnail: () => Promise<String>;
  filename: () => Promise<String>;
  encoding: () => Promise<String>;
  size: () => Promise<Int>;
  width: () => Promise<Int>;
  height: () => Promise<Int>;
  duration: () => Promise<Float>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface FileSubscription
  extends Promise<AsyncIterator<File>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  user: <T = UserSubscription>() => T;
  path: () => Promise<AsyncIterator<String>>;
  comment: () => Promise<AsyncIterator<String>>;
  mimetype: () => Promise<AsyncIterator<String>>;
  thumbnail: () => Promise<AsyncIterator<String>>;
  filename: () => Promise<AsyncIterator<String>>;
  encoding: () => Promise<AsyncIterator<String>>;
  size: () => Promise<AsyncIterator<Int>>;
  width: () => Promise<AsyncIterator<Int>>;
  height: () => Promise<AsyncIterator<Int>>;
  duration: () => Promise<AsyncIterator<Float>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
}

export interface FileNullablePromise
  extends Promise<File | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  user: <T = UserPromise>() => T;
  path: () => Promise<String>;
  comment: () => Promise<String>;
  mimetype: () => Promise<String>;
  thumbnail: () => Promise<String>;
  filename: () => Promise<String>;
  encoding: () => Promise<String>;
  size: () => Promise<Int>;
  width: () => Promise<Int>;
  height: () => Promise<Int>;
  duration: () => Promise<Float>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface User {
  id: ID_Output;
  email: String;
  name: String;
  password: String;
  resetToken?: String;
  resetTokenExpiry?: Float;
  createdAt: DateTimeOutput;
  permissions: Permission[];
  interests: String[];
}

export interface UserPromise extends Promise<User>, Fragmentable {
  id: () => Promise<ID_Output>;
  email: () => Promise<String>;
  name: () => Promise<String>;
  password: () => Promise<String>;
  resetToken: () => Promise<String>;
  resetTokenExpiry: () => Promise<Float>;
  createdAt: () => Promise<DateTimeOutput>;
  comments: <T = FragmentableArray<Comment>>(args?: {
    where?: CommentWhereInput;
    orderBy?: CommentOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  ratings: <T = FragmentableArray<Rating>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  permissions: () => Promise<Permission[]>;
  interests: () => Promise<String[]>;
}

export interface UserSubscription
  extends Promise<AsyncIterator<User>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  email: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  password: () => Promise<AsyncIterator<String>>;
  resetToken: () => Promise<AsyncIterator<String>>;
  resetTokenExpiry: () => Promise<AsyncIterator<Float>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  comments: <T = Promise<AsyncIterator<CommentSubscription>>>(args?: {
    where?: CommentWhereInput;
    orderBy?: CommentOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  ratings: <T = Promise<AsyncIterator<RatingSubscription>>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  permissions: () => Promise<AsyncIterator<Permission[]>>;
  interests: () => Promise<AsyncIterator<String[]>>;
}

export interface UserNullablePromise
  extends Promise<User | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  email: () => Promise<String>;
  name: () => Promise<String>;
  password: () => Promise<String>;
  resetToken: () => Promise<String>;
  resetTokenExpiry: () => Promise<Float>;
  createdAt: () => Promise<DateTimeOutput>;
  comments: <T = FragmentableArray<Comment>>(args?: {
    where?: CommentWhereInput;
    orderBy?: CommentOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  ratings: <T = FragmentableArray<Rating>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  permissions: () => Promise<Permission[]>;
  interests: () => Promise<String[]>;
}

export interface Comment {
  id: ID_Output;
  text: String;
  createdAt: DateTimeOutput;
}

export interface CommentPromise extends Promise<Comment>, Fragmentable {
  id: () => Promise<ID_Output>;
  text: () => Promise<String>;
  author: <T = UserPromise>() => T;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface CommentSubscription
  extends Promise<AsyncIterator<Comment>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  text: () => Promise<AsyncIterator<String>>;
  author: <T = UserSubscription>() => T;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface CommentNullablePromise
  extends Promise<Comment | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  text: () => Promise<String>;
  author: <T = UserPromise>() => T;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface Rating {
  id: ID_Output;
  value: Int;
  comment: String;
  createdAt: DateTimeOutput;
}

export interface RatingPromise extends Promise<Rating>, Fragmentable {
  id: () => Promise<ID_Output>;
  user: <T = UserPromise>() => T;
  value: () => Promise<Int>;
  comment: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface RatingSubscription
  extends Promise<AsyncIterator<Rating>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  user: <T = UserSubscription>() => T;
  value: () => Promise<AsyncIterator<Int>>;
  comment: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface RatingNullablePromise
  extends Promise<Rating | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  user: <T = UserPromise>() => T;
  value: () => Promise<Int>;
  comment: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface Link {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  url: String;
  comment?: String;
  duration?: Int;
  title?: String;
  artist?: String;
}

export interface LinkPromise extends Promise<Link>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  url: () => Promise<String>;
  user: <T = UserPromise>() => T;
  comment: () => Promise<String>;
  duration: () => Promise<Int>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface LinkSubscription
  extends Promise<AsyncIterator<Link>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  url: () => Promise<AsyncIterator<String>>;
  user: <T = UserSubscription>() => T;
  comment: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
}

export interface LinkNullablePromise
  extends Promise<Link | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  url: () => Promise<String>;
  user: <T = UserPromise>() => T;
  comment: () => Promise<String>;
  duration: () => Promise<Int>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface Video {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface VideoPromise extends Promise<Video>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface VideoSubscription
  extends Promise<AsyncIterator<Video>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
  file: <T = FileSubscription>() => T;
  link: <T = LinkSubscription>() => T;
}

export interface VideoNullablePromise
  extends Promise<Video | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface Picture {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface PicturePromise extends Promise<Picture>, Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface PictureSubscription
  extends Promise<AsyncIterator<Picture>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
  file: <T = FileSubscription>() => T;
  link: <T = LinkSubscription>() => T;
}

export interface PictureNullablePromise
  extends Promise<Picture | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
  file: <T = FilePromise>() => T;
  link: <T = LinkPromise>() => T;
}

export interface BlockInstance {
  id: ID_Output;
  order: Int;
  rounds?: Int;
  variation?: String;
}

export interface BlockInstancePromise
  extends Promise<BlockInstance>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  block: <T = BlockPromise>() => T;
  parentBlock: <T = BlockPromise>() => T;
  parentTraining: <T = TrainingPromise>() => T;
  order: () => Promise<Int>;
  rounds: () => Promise<Int>;
  variation: () => Promise<String>;
}

export interface BlockInstanceSubscription
  extends Promise<AsyncIterator<BlockInstance>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  block: <T = BlockSubscription>() => T;
  parentBlock: <T = BlockSubscription>() => T;
  parentTraining: <T = TrainingSubscription>() => T;
  order: () => Promise<AsyncIterator<Int>>;
  rounds: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
}

export interface BlockInstanceNullablePromise
  extends Promise<BlockInstance | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  block: <T = BlockPromise>() => T;
  parentBlock: <T = BlockPromise>() => T;
  parentTraining: <T = TrainingPromise>() => T;
  order: () => Promise<Int>;
  rounds: () => Promise<Int>;
  variation: () => Promise<String>;
}

export interface Training {
  id: ID_Output;
  title: String;
  createdAt: DateTimeOutput;
  trainingDate: DateTimeOutput;
  location: String;
  attendance?: Int;
  published: Boolean;
}

export interface TrainingPromise extends Promise<Training>, Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  type: <T = TrainingTypePromise>() => T;
  createdAt: () => Promise<DateTimeOutput>;
  trainingDate: () => Promise<DateTimeOutput>;
  location: () => Promise<String>;
  registrations: <T = FragmentableArray<User>>(args?: {
    where?: UserWhereInput;
    orderBy?: UserOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  attendance: () => Promise<Int>;
  ratings: <T = FragmentableArray<Rating>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  published: () => Promise<Boolean>;
  blocks: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface TrainingSubscription
  extends Promise<AsyncIterator<Training>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  type: <T = TrainingTypeSubscription>() => T;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  trainingDate: () => Promise<AsyncIterator<DateTimeOutput>>;
  location: () => Promise<AsyncIterator<String>>;
  registrations: <T = Promise<AsyncIterator<UserSubscription>>>(args?: {
    where?: UserWhereInput;
    orderBy?: UserOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  attendance: () => Promise<AsyncIterator<Int>>;
  ratings: <T = Promise<AsyncIterator<RatingSubscription>>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  published: () => Promise<AsyncIterator<Boolean>>;
  blocks: <T = Promise<AsyncIterator<BlockInstanceSubscription>>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface TrainingNullablePromise
  extends Promise<Training | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  type: <T = TrainingTypePromise>() => T;
  createdAt: () => Promise<DateTimeOutput>;
  trainingDate: () => Promise<DateTimeOutput>;
  location: () => Promise<String>;
  registrations: <T = FragmentableArray<User>>(args?: {
    where?: UserWhereInput;
    orderBy?: UserOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  attendance: () => Promise<Int>;
  ratings: <T = FragmentableArray<Rating>>(args?: {
    where?: RatingWhereInput;
    orderBy?: RatingOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  published: () => Promise<Boolean>;
  blocks: <T = FragmentableArray<BlockInstance>>(args?: {
    where?: BlockInstanceWhereInput;
    orderBy?: BlockInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface TrainingType {
  id: ID_Output;
  name: String;
  description: String;
}

export interface TrainingTypePromise
  extends Promise<TrainingType>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface TrainingTypeSubscription
  extends Promise<AsyncIterator<TrainingType>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface TrainingTypeNullablePromise
  extends Promise<TrainingType | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface ExerciseInstance {
  id: ID_Output;
  order: Int;
  repetitions?: Int;
  variation?: String;
}

export interface ExerciseInstancePromise
  extends Promise<ExerciseInstance>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  exercise: <T = ExercisePromise>() => T;
  order: () => Promise<Int>;
  repetitions: () => Promise<Int>;
  variation: () => Promise<String>;
  parentBlockInstances: <T = BlockPromise>() => T;
}

export interface ExerciseInstanceSubscription
  extends Promise<AsyncIterator<ExerciseInstance>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  exercise: <T = ExerciseSubscription>() => T;
  order: () => Promise<AsyncIterator<Int>>;
  repetitions: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
  parentBlockInstances: <T = BlockSubscription>() => T;
}

export interface ExerciseInstanceNullablePromise
  extends Promise<ExerciseInstance | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  exercise: <T = ExercisePromise>() => T;
  order: () => Promise<Int>;
  repetitions: () => Promise<Int>;
  variation: () => Promise<String>;
  parentBlockInstances: <T = BlockPromise>() => T;
}

export interface Exercise {
  id: ID_Output;
  name: String;
  description?: String;
  targets: String[];
  baseExercise: String[];
}

export interface ExercisePromise extends Promise<Exercise>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  videos: <T = FragmentableArray<Video>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = FragmentableArray<Picture>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  targets: () => Promise<String[]>;
  baseExercise: () => Promise<String[]>;
  parentExerciseInstances: <T = FragmentableArray<ExerciseInstance>>(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface ExerciseSubscription
  extends Promise<AsyncIterator<Exercise>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  videos: <T = Promise<AsyncIterator<VideoSubscription>>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = Promise<AsyncIterator<PictureSubscription>>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  targets: () => Promise<AsyncIterator<String[]>>;
  baseExercise: () => Promise<AsyncIterator<String[]>>;
  parentExerciseInstances: <
    T = Promise<AsyncIterator<ExerciseInstanceSubscription>>
  >(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface ExerciseNullablePromise
  extends Promise<Exercise | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  videos: <T = FragmentableArray<Video>>(args?: {
    where?: VideoWhereInput;
    orderBy?: VideoOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  pictures: <T = FragmentableArray<Picture>>(args?: {
    where?: PictureWhereInput;
    orderBy?: PictureOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  targets: () => Promise<String[]>;
  baseExercise: () => Promise<String[]>;
  parentExerciseInstances: <T = FragmentableArray<ExerciseInstance>>(args?: {
    where?: ExerciseInstanceWhereInput;
    orderBy?: ExerciseInstanceOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface BlockConnection {
  pageInfo: PageInfo;
  edges: BlockEdge[];
}

export interface BlockConnectionPromise
  extends Promise<BlockConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<BlockEdge>>() => T;
  aggregate: <T = AggregateBlockPromise>() => T;
}

export interface BlockConnectionSubscription
  extends Promise<AsyncIterator<BlockConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<BlockEdgeSubscription>>>() => T;
  aggregate: <T = AggregateBlockSubscription>() => T;
}

export interface PageInfo {
  hasNextPage: Boolean;
  hasPreviousPage: Boolean;
  startCursor?: String;
  endCursor?: String;
}

export interface PageInfoPromise extends Promise<PageInfo>, Fragmentable {
  hasNextPage: () => Promise<Boolean>;
  hasPreviousPage: () => Promise<Boolean>;
  startCursor: () => Promise<String>;
  endCursor: () => Promise<String>;
}

export interface PageInfoSubscription
  extends Promise<AsyncIterator<PageInfo>>,
    Fragmentable {
  hasNextPage: () => Promise<AsyncIterator<Boolean>>;
  hasPreviousPage: () => Promise<AsyncIterator<Boolean>>;
  startCursor: () => Promise<AsyncIterator<String>>;
  endCursor: () => Promise<AsyncIterator<String>>;
}

export interface BlockEdge {
  node: Block;
  cursor: String;
}

export interface BlockEdgePromise extends Promise<BlockEdge>, Fragmentable {
  node: <T = BlockPromise>() => T;
  cursor: () => Promise<String>;
}

export interface BlockEdgeSubscription
  extends Promise<AsyncIterator<BlockEdge>>,
    Fragmentable {
  node: <T = BlockSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateBlock {
  count: Int;
}

export interface AggregateBlockPromise
  extends Promise<AggregateBlock>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateBlockSubscription
  extends Promise<AsyncIterator<AggregateBlock>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface BlockInstanceConnection {
  pageInfo: PageInfo;
  edges: BlockInstanceEdge[];
}

export interface BlockInstanceConnectionPromise
  extends Promise<BlockInstanceConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<BlockInstanceEdge>>() => T;
  aggregate: <T = AggregateBlockInstancePromise>() => T;
}

export interface BlockInstanceConnectionSubscription
  extends Promise<AsyncIterator<BlockInstanceConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<BlockInstanceEdgeSubscription>>>() => T;
  aggregate: <T = AggregateBlockInstanceSubscription>() => T;
}

export interface BlockInstanceEdge {
  node: BlockInstance;
  cursor: String;
}

export interface BlockInstanceEdgePromise
  extends Promise<BlockInstanceEdge>,
    Fragmentable {
  node: <T = BlockInstancePromise>() => T;
  cursor: () => Promise<String>;
}

export interface BlockInstanceEdgeSubscription
  extends Promise<AsyncIterator<BlockInstanceEdge>>,
    Fragmentable {
  node: <T = BlockInstanceSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateBlockInstance {
  count: Int;
}

export interface AggregateBlockInstancePromise
  extends Promise<AggregateBlockInstance>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateBlockInstanceSubscription
  extends Promise<AsyncIterator<AggregateBlockInstance>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface CommentConnection {
  pageInfo: PageInfo;
  edges: CommentEdge[];
}

export interface CommentConnectionPromise
  extends Promise<CommentConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<CommentEdge>>() => T;
  aggregate: <T = AggregateCommentPromise>() => T;
}

export interface CommentConnectionSubscription
  extends Promise<AsyncIterator<CommentConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<CommentEdgeSubscription>>>() => T;
  aggregate: <T = AggregateCommentSubscription>() => T;
}

export interface CommentEdge {
  node: Comment;
  cursor: String;
}

export interface CommentEdgePromise extends Promise<CommentEdge>, Fragmentable {
  node: <T = CommentPromise>() => T;
  cursor: () => Promise<String>;
}

export interface CommentEdgeSubscription
  extends Promise<AsyncIterator<CommentEdge>>,
    Fragmentable {
  node: <T = CommentSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateComment {
  count: Int;
}

export interface AggregateCommentPromise
  extends Promise<AggregateComment>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateCommentSubscription
  extends Promise<AsyncIterator<AggregateComment>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface ExerciseConnection {
  pageInfo: PageInfo;
  edges: ExerciseEdge[];
}

export interface ExerciseConnectionPromise
  extends Promise<ExerciseConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<ExerciseEdge>>() => T;
  aggregate: <T = AggregateExercisePromise>() => T;
}

export interface ExerciseConnectionSubscription
  extends Promise<AsyncIterator<ExerciseConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<ExerciseEdgeSubscription>>>() => T;
  aggregate: <T = AggregateExerciseSubscription>() => T;
}

export interface ExerciseEdge {
  node: Exercise;
  cursor: String;
}

export interface ExerciseEdgePromise
  extends Promise<ExerciseEdge>,
    Fragmentable {
  node: <T = ExercisePromise>() => T;
  cursor: () => Promise<String>;
}

export interface ExerciseEdgeSubscription
  extends Promise<AsyncIterator<ExerciseEdge>>,
    Fragmentable {
  node: <T = ExerciseSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateExercise {
  count: Int;
}

export interface AggregateExercisePromise
  extends Promise<AggregateExercise>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateExerciseSubscription
  extends Promise<AsyncIterator<AggregateExercise>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface ExerciseInstanceConnection {
  pageInfo: PageInfo;
  edges: ExerciseInstanceEdge[];
}

export interface ExerciseInstanceConnectionPromise
  extends Promise<ExerciseInstanceConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<ExerciseInstanceEdge>>() => T;
  aggregate: <T = AggregateExerciseInstancePromise>() => T;
}

export interface ExerciseInstanceConnectionSubscription
  extends Promise<AsyncIterator<ExerciseInstanceConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<ExerciseInstanceEdgeSubscription>>>() => T;
  aggregate: <T = AggregateExerciseInstanceSubscription>() => T;
}

export interface ExerciseInstanceEdge {
  node: ExerciseInstance;
  cursor: String;
}

export interface ExerciseInstanceEdgePromise
  extends Promise<ExerciseInstanceEdge>,
    Fragmentable {
  node: <T = ExerciseInstancePromise>() => T;
  cursor: () => Promise<String>;
}

export interface ExerciseInstanceEdgeSubscription
  extends Promise<AsyncIterator<ExerciseInstanceEdge>>,
    Fragmentable {
  node: <T = ExerciseInstanceSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateExerciseInstance {
  count: Int;
}

export interface AggregateExerciseInstancePromise
  extends Promise<AggregateExerciseInstance>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateExerciseInstanceSubscription
  extends Promise<AsyncIterator<AggregateExerciseInstance>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface FileConnection {
  pageInfo: PageInfo;
  edges: FileEdge[];
}

export interface FileConnectionPromise
  extends Promise<FileConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<FileEdge>>() => T;
  aggregate: <T = AggregateFilePromise>() => T;
}

export interface FileConnectionSubscription
  extends Promise<AsyncIterator<FileConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<FileEdgeSubscription>>>() => T;
  aggregate: <T = AggregateFileSubscription>() => T;
}

export interface FileEdge {
  node: File;
  cursor: String;
}

export interface FileEdgePromise extends Promise<FileEdge>, Fragmentable {
  node: <T = FilePromise>() => T;
  cursor: () => Promise<String>;
}

export interface FileEdgeSubscription
  extends Promise<AsyncIterator<FileEdge>>,
    Fragmentable {
  node: <T = FileSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateFile {
  count: Int;
}

export interface AggregateFilePromise
  extends Promise<AggregateFile>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateFileSubscription
  extends Promise<AsyncIterator<AggregateFile>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface FormatConnection {
  pageInfo: PageInfo;
  edges: FormatEdge[];
}

export interface FormatConnectionPromise
  extends Promise<FormatConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<FormatEdge>>() => T;
  aggregate: <T = AggregateFormatPromise>() => T;
}

export interface FormatConnectionSubscription
  extends Promise<AsyncIterator<FormatConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<FormatEdgeSubscription>>>() => T;
  aggregate: <T = AggregateFormatSubscription>() => T;
}

export interface FormatEdge {
  node: Format;
  cursor: String;
}

export interface FormatEdgePromise extends Promise<FormatEdge>, Fragmentable {
  node: <T = FormatPromise>() => T;
  cursor: () => Promise<String>;
}

export interface FormatEdgeSubscription
  extends Promise<AsyncIterator<FormatEdge>>,
    Fragmentable {
  node: <T = FormatSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateFormat {
  count: Int;
}

export interface AggregateFormatPromise
  extends Promise<AggregateFormat>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateFormatSubscription
  extends Promise<AsyncIterator<AggregateFormat>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface LinkConnection {
  pageInfo: PageInfo;
  edges: LinkEdge[];
}

export interface LinkConnectionPromise
  extends Promise<LinkConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<LinkEdge>>() => T;
  aggregate: <T = AggregateLinkPromise>() => T;
}

export interface LinkConnectionSubscription
  extends Promise<AsyncIterator<LinkConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<LinkEdgeSubscription>>>() => T;
  aggregate: <T = AggregateLinkSubscription>() => T;
}

export interface LinkEdge {
  node: Link;
  cursor: String;
}

export interface LinkEdgePromise extends Promise<LinkEdge>, Fragmentable {
  node: <T = LinkPromise>() => T;
  cursor: () => Promise<String>;
}

export interface LinkEdgeSubscription
  extends Promise<AsyncIterator<LinkEdge>>,
    Fragmentable {
  node: <T = LinkSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateLink {
  count: Int;
}

export interface AggregateLinkPromise
  extends Promise<AggregateLink>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateLinkSubscription
  extends Promise<AsyncIterator<AggregateLink>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface PictureConnection {
  pageInfo: PageInfo;
  edges: PictureEdge[];
}

export interface PictureConnectionPromise
  extends Promise<PictureConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<PictureEdge>>() => T;
  aggregate: <T = AggregatePicturePromise>() => T;
}

export interface PictureConnectionSubscription
  extends Promise<AsyncIterator<PictureConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<PictureEdgeSubscription>>>() => T;
  aggregate: <T = AggregatePictureSubscription>() => T;
}

export interface PictureEdge {
  node: Picture;
  cursor: String;
}

export interface PictureEdgePromise extends Promise<PictureEdge>, Fragmentable {
  node: <T = PicturePromise>() => T;
  cursor: () => Promise<String>;
}

export interface PictureEdgeSubscription
  extends Promise<AsyncIterator<PictureEdge>>,
    Fragmentable {
  node: <T = PictureSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregatePicture {
  count: Int;
}

export interface AggregatePicturePromise
  extends Promise<AggregatePicture>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregatePictureSubscription
  extends Promise<AsyncIterator<AggregatePicture>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface RatingConnection {
  pageInfo: PageInfo;
  edges: RatingEdge[];
}

export interface RatingConnectionPromise
  extends Promise<RatingConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<RatingEdge>>() => T;
  aggregate: <T = AggregateRatingPromise>() => T;
}

export interface RatingConnectionSubscription
  extends Promise<AsyncIterator<RatingConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<RatingEdgeSubscription>>>() => T;
  aggregate: <T = AggregateRatingSubscription>() => T;
}

export interface RatingEdge {
  node: Rating;
  cursor: String;
}

export interface RatingEdgePromise extends Promise<RatingEdge>, Fragmentable {
  node: <T = RatingPromise>() => T;
  cursor: () => Promise<String>;
}

export interface RatingEdgeSubscription
  extends Promise<AsyncIterator<RatingEdge>>,
    Fragmentable {
  node: <T = RatingSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateRating {
  count: Int;
}

export interface AggregateRatingPromise
  extends Promise<AggregateRating>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateRatingSubscription
  extends Promise<AsyncIterator<AggregateRating>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface TrackConnection {
  pageInfo: PageInfo;
  edges: TrackEdge[];
}

export interface TrackConnectionPromise
  extends Promise<TrackConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<TrackEdge>>() => T;
  aggregate: <T = AggregateTrackPromise>() => T;
}

export interface TrackConnectionSubscription
  extends Promise<AsyncIterator<TrackConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<TrackEdgeSubscription>>>() => T;
  aggregate: <T = AggregateTrackSubscription>() => T;
}

export interface TrackEdge {
  node: Track;
  cursor: String;
}

export interface TrackEdgePromise extends Promise<TrackEdge>, Fragmentable {
  node: <T = TrackPromise>() => T;
  cursor: () => Promise<String>;
}

export interface TrackEdgeSubscription
  extends Promise<AsyncIterator<TrackEdge>>,
    Fragmentable {
  node: <T = TrackSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateTrack {
  count: Int;
}

export interface AggregateTrackPromise
  extends Promise<AggregateTrack>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateTrackSubscription
  extends Promise<AsyncIterator<AggregateTrack>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface TrainingConnection {
  pageInfo: PageInfo;
  edges: TrainingEdge[];
}

export interface TrainingConnectionPromise
  extends Promise<TrainingConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<TrainingEdge>>() => T;
  aggregate: <T = AggregateTrainingPromise>() => T;
}

export interface TrainingConnectionSubscription
  extends Promise<AsyncIterator<TrainingConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<TrainingEdgeSubscription>>>() => T;
  aggregate: <T = AggregateTrainingSubscription>() => T;
}

export interface TrainingEdge {
  node: Training;
  cursor: String;
}

export interface TrainingEdgePromise
  extends Promise<TrainingEdge>,
    Fragmentable {
  node: <T = TrainingPromise>() => T;
  cursor: () => Promise<String>;
}

export interface TrainingEdgeSubscription
  extends Promise<AsyncIterator<TrainingEdge>>,
    Fragmentable {
  node: <T = TrainingSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateTraining {
  count: Int;
}

export interface AggregateTrainingPromise
  extends Promise<AggregateTraining>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateTrainingSubscription
  extends Promise<AsyncIterator<AggregateTraining>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface TrainingTypeConnection {
  pageInfo: PageInfo;
  edges: TrainingTypeEdge[];
}

export interface TrainingTypeConnectionPromise
  extends Promise<TrainingTypeConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<TrainingTypeEdge>>() => T;
  aggregate: <T = AggregateTrainingTypePromise>() => T;
}

export interface TrainingTypeConnectionSubscription
  extends Promise<AsyncIterator<TrainingTypeConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<TrainingTypeEdgeSubscription>>>() => T;
  aggregate: <T = AggregateTrainingTypeSubscription>() => T;
}

export interface TrainingTypeEdge {
  node: TrainingType;
  cursor: String;
}

export interface TrainingTypeEdgePromise
  extends Promise<TrainingTypeEdge>,
    Fragmentable {
  node: <T = TrainingTypePromise>() => T;
  cursor: () => Promise<String>;
}

export interface TrainingTypeEdgeSubscription
  extends Promise<AsyncIterator<TrainingTypeEdge>>,
    Fragmentable {
  node: <T = TrainingTypeSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateTrainingType {
  count: Int;
}

export interface AggregateTrainingTypePromise
  extends Promise<AggregateTrainingType>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateTrainingTypeSubscription
  extends Promise<AsyncIterator<AggregateTrainingType>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface UserConnection {
  pageInfo: PageInfo;
  edges: UserEdge[];
}

export interface UserConnectionPromise
  extends Promise<UserConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<UserEdge>>() => T;
  aggregate: <T = AggregateUserPromise>() => T;
}

export interface UserConnectionSubscription
  extends Promise<AsyncIterator<UserConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<UserEdgeSubscription>>>() => T;
  aggregate: <T = AggregateUserSubscription>() => T;
}

export interface UserEdge {
  node: User;
  cursor: String;
}

export interface UserEdgePromise extends Promise<UserEdge>, Fragmentable {
  node: <T = UserPromise>() => T;
  cursor: () => Promise<String>;
}

export interface UserEdgeSubscription
  extends Promise<AsyncIterator<UserEdge>>,
    Fragmentable {
  node: <T = UserSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateUser {
  count: Int;
}

export interface AggregateUserPromise
  extends Promise<AggregateUser>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateUserSubscription
  extends Promise<AsyncIterator<AggregateUser>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface VideoConnection {
  pageInfo: PageInfo;
  edges: VideoEdge[];
}

export interface VideoConnectionPromise
  extends Promise<VideoConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<VideoEdge>>() => T;
  aggregate: <T = AggregateVideoPromise>() => T;
}

export interface VideoConnectionSubscription
  extends Promise<AsyncIterator<VideoConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<VideoEdgeSubscription>>>() => T;
  aggregate: <T = AggregateVideoSubscription>() => T;
}

export interface VideoEdge {
  node: Video;
  cursor: String;
}

export interface VideoEdgePromise extends Promise<VideoEdge>, Fragmentable {
  node: <T = VideoPromise>() => T;
  cursor: () => Promise<String>;
}

export interface VideoEdgeSubscription
  extends Promise<AsyncIterator<VideoEdge>>,
    Fragmentable {
  node: <T = VideoSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateVideo {
  count: Int;
}

export interface AggregateVideoPromise
  extends Promise<AggregateVideo>,
    Fragmentable {
  count: () => Promise<Int>;
}

export interface AggregateVideoSubscription
  extends Promise<AsyncIterator<AggregateVideo>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Int>>;
}

export interface BatchPayload {
  count: Long;
}

export interface BatchPayloadPromise
  extends Promise<BatchPayload>,
    Fragmentable {
  count: () => Promise<Long>;
}

export interface BatchPayloadSubscription
  extends Promise<AsyncIterator<BatchPayload>>,
    Fragmentable {
  count: () => Promise<AsyncIterator<Long>>;
}

export interface BlockSubscriptionPayload {
  mutation: MutationType;
  node: Block;
  updatedFields: String[];
  previousValues: BlockPreviousValues;
}

export interface BlockSubscriptionPayloadPromise
  extends Promise<BlockSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = BlockPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = BlockPreviousValuesPromise>() => T;
}

export interface BlockSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<BlockSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = BlockSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = BlockPreviousValuesSubscription>() => T;
}

export interface BlockPreviousValues {
  id: ID_Output;
  title: String;
  description?: String;
  duration?: Int;
  rest?: Int;
}

export interface BlockPreviousValuesPromise
  extends Promise<BlockPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  description: () => Promise<String>;
  duration: () => Promise<Int>;
  rest: () => Promise<Int>;
}

export interface BlockPreviousValuesSubscription
  extends Promise<AsyncIterator<BlockPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  rest: () => Promise<AsyncIterator<Int>>;
}

export interface BlockInstanceSubscriptionPayload {
  mutation: MutationType;
  node: BlockInstance;
  updatedFields: String[];
  previousValues: BlockInstancePreviousValues;
}

export interface BlockInstanceSubscriptionPayloadPromise
  extends Promise<BlockInstanceSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = BlockInstancePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = BlockInstancePreviousValuesPromise>() => T;
}

export interface BlockInstanceSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<BlockInstanceSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = BlockInstanceSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = BlockInstancePreviousValuesSubscription>() => T;
}

export interface BlockInstancePreviousValues {
  id: ID_Output;
  order: Int;
  rounds?: Int;
  variation?: String;
}

export interface BlockInstancePreviousValuesPromise
  extends Promise<BlockInstancePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  order: () => Promise<Int>;
  rounds: () => Promise<Int>;
  variation: () => Promise<String>;
}

export interface BlockInstancePreviousValuesSubscription
  extends Promise<AsyncIterator<BlockInstancePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  order: () => Promise<AsyncIterator<Int>>;
  rounds: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
}

export interface CommentSubscriptionPayload {
  mutation: MutationType;
  node: Comment;
  updatedFields: String[];
  previousValues: CommentPreviousValues;
}

export interface CommentSubscriptionPayloadPromise
  extends Promise<CommentSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = CommentPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = CommentPreviousValuesPromise>() => T;
}

export interface CommentSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<CommentSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = CommentSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = CommentPreviousValuesSubscription>() => T;
}

export interface CommentPreviousValues {
  id: ID_Output;
  text: String;
  createdAt: DateTimeOutput;
}

export interface CommentPreviousValuesPromise
  extends Promise<CommentPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  text: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface CommentPreviousValuesSubscription
  extends Promise<AsyncIterator<CommentPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  text: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface ExerciseSubscriptionPayload {
  mutation: MutationType;
  node: Exercise;
  updatedFields: String[];
  previousValues: ExercisePreviousValues;
}

export interface ExerciseSubscriptionPayloadPromise
  extends Promise<ExerciseSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = ExercisePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = ExercisePreviousValuesPromise>() => T;
}

export interface ExerciseSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<ExerciseSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = ExerciseSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = ExercisePreviousValuesSubscription>() => T;
}

export interface ExercisePreviousValues {
  id: ID_Output;
  name: String;
  description?: String;
  targets: String[];
  baseExercise: String[];
}

export interface ExercisePreviousValuesPromise
  extends Promise<ExercisePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  targets: () => Promise<String[]>;
  baseExercise: () => Promise<String[]>;
}

export interface ExercisePreviousValuesSubscription
  extends Promise<AsyncIterator<ExercisePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  targets: () => Promise<AsyncIterator<String[]>>;
  baseExercise: () => Promise<AsyncIterator<String[]>>;
}

export interface ExerciseInstanceSubscriptionPayload {
  mutation: MutationType;
  node: ExerciseInstance;
  updatedFields: String[];
  previousValues: ExerciseInstancePreviousValues;
}

export interface ExerciseInstanceSubscriptionPayloadPromise
  extends Promise<ExerciseInstanceSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = ExerciseInstancePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = ExerciseInstancePreviousValuesPromise>() => T;
}

export interface ExerciseInstanceSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<ExerciseInstanceSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = ExerciseInstanceSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = ExerciseInstancePreviousValuesSubscription>() => T;
}

export interface ExerciseInstancePreviousValues {
  id: ID_Output;
  order: Int;
  repetitions?: Int;
  variation?: String;
}

export interface ExerciseInstancePreviousValuesPromise
  extends Promise<ExerciseInstancePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  order: () => Promise<Int>;
  repetitions: () => Promise<Int>;
  variation: () => Promise<String>;
}

export interface ExerciseInstancePreviousValuesSubscription
  extends Promise<AsyncIterator<ExerciseInstancePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  order: () => Promise<AsyncIterator<Int>>;
  repetitions: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
}

export interface FileSubscriptionPayload {
  mutation: MutationType;
  node: File;
  updatedFields: String[];
  previousValues: FilePreviousValues;
}

export interface FileSubscriptionPayloadPromise
  extends Promise<FileSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = FilePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = FilePreviousValuesPromise>() => T;
}

export interface FileSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<FileSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = FileSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = FilePreviousValuesSubscription>() => T;
}

export interface FilePreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  path: String;
  comment?: String;
  mimetype?: String;
  thumbnail?: String;
  filename?: String;
  encoding?: String;
  size?: Int;
  width?: Int;
  height?: Int;
  duration?: Float;
  title?: String;
  artist?: String;
}

export interface FilePreviousValuesPromise
  extends Promise<FilePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  path: () => Promise<String>;
  comment: () => Promise<String>;
  mimetype: () => Promise<String>;
  thumbnail: () => Promise<String>;
  filename: () => Promise<String>;
  encoding: () => Promise<String>;
  size: () => Promise<Int>;
  width: () => Promise<Int>;
  height: () => Promise<Int>;
  duration: () => Promise<Float>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface FilePreviousValuesSubscription
  extends Promise<AsyncIterator<FilePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  path: () => Promise<AsyncIterator<String>>;
  comment: () => Promise<AsyncIterator<String>>;
  mimetype: () => Promise<AsyncIterator<String>>;
  thumbnail: () => Promise<AsyncIterator<String>>;
  filename: () => Promise<AsyncIterator<String>>;
  encoding: () => Promise<AsyncIterator<String>>;
  size: () => Promise<AsyncIterator<Int>>;
  width: () => Promise<AsyncIterator<Int>>;
  height: () => Promise<AsyncIterator<Int>>;
  duration: () => Promise<AsyncIterator<Float>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
}

export interface FormatSubscriptionPayload {
  mutation: MutationType;
  node: Format;
  updatedFields: String[];
  previousValues: FormatPreviousValues;
}

export interface FormatSubscriptionPayloadPromise
  extends Promise<FormatSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = FormatPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = FormatPreviousValuesPromise>() => T;
}

export interface FormatSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<FormatSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = FormatSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = FormatPreviousValuesSubscription>() => T;
}

export interface FormatPreviousValues {
  id: ID_Output;
  name: String;
  description: String;
}

export interface FormatPreviousValuesPromise
  extends Promise<FormatPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface FormatPreviousValuesSubscription
  extends Promise<AsyncIterator<FormatPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface LinkSubscriptionPayload {
  mutation: MutationType;
  node: Link;
  updatedFields: String[];
  previousValues: LinkPreviousValues;
}

export interface LinkSubscriptionPayloadPromise
  extends Promise<LinkSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = LinkPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = LinkPreviousValuesPromise>() => T;
}

export interface LinkSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<LinkSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = LinkSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = LinkPreviousValuesSubscription>() => T;
}

export interface LinkPreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  url: String;
  comment?: String;
  duration?: Int;
  title?: String;
  artist?: String;
}

export interface LinkPreviousValuesPromise
  extends Promise<LinkPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  url: () => Promise<String>;
  comment: () => Promise<String>;
  duration: () => Promise<Int>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
}

export interface LinkPreviousValuesSubscription
  extends Promise<AsyncIterator<LinkPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  url: () => Promise<AsyncIterator<String>>;
  comment: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
}

export interface PictureSubscriptionPayload {
  mutation: MutationType;
  node: Picture;
  updatedFields: String[];
  previousValues: PicturePreviousValues;
}

export interface PictureSubscriptionPayloadPromise
  extends Promise<PictureSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = PicturePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = PicturePreviousValuesPromise>() => T;
}

export interface PictureSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<PictureSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = PictureSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = PicturePreviousValuesSubscription>() => T;
}

export interface PicturePreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface PicturePreviousValuesPromise
  extends Promise<PicturePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
}

export interface PicturePreviousValuesSubscription
  extends Promise<AsyncIterator<PicturePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
}

export interface RatingSubscriptionPayload {
  mutation: MutationType;
  node: Rating;
  updatedFields: String[];
  previousValues: RatingPreviousValues;
}

export interface RatingSubscriptionPayloadPromise
  extends Promise<RatingSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = RatingPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = RatingPreviousValuesPromise>() => T;
}

export interface RatingSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<RatingSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = RatingSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = RatingPreviousValuesSubscription>() => T;
}

export interface RatingPreviousValues {
  id: ID_Output;
  value: Int;
  comment: String;
  createdAt: DateTimeOutput;
}

export interface RatingPreviousValuesPromise
  extends Promise<RatingPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  value: () => Promise<Int>;
  comment: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
}

export interface RatingPreviousValuesSubscription
  extends Promise<AsyncIterator<RatingPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  value: () => Promise<AsyncIterator<Int>>;
  comment: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
}

export interface TrackSubscriptionPayload {
  mutation: MutationType;
  node: Track;
  updatedFields: String[];
  previousValues: TrackPreviousValues;
}

export interface TrackSubscriptionPayloadPromise
  extends Promise<TrackSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = TrackPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = TrackPreviousValuesPromise>() => T;
}

export interface TrackSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<TrackSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = TrackSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = TrackPreviousValuesSubscription>() => T;
}

export interface TrackPreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface TrackPreviousValuesPromise
  extends Promise<TrackPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
}

export interface TrackPreviousValuesSubscription
  extends Promise<AsyncIterator<TrackPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
}

export interface TrainingSubscriptionPayload {
  mutation: MutationType;
  node: Training;
  updatedFields: String[];
  previousValues: TrainingPreviousValues;
}

export interface TrainingSubscriptionPayloadPromise
  extends Promise<TrainingSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = TrainingPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = TrainingPreviousValuesPromise>() => T;
}

export interface TrainingSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<TrainingSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = TrainingSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = TrainingPreviousValuesSubscription>() => T;
}

export interface TrainingPreviousValues {
  id: ID_Output;
  title: String;
  createdAt: DateTimeOutput;
  trainingDate: DateTimeOutput;
  location: String;
  attendance?: Int;
  published: Boolean;
}

export interface TrainingPreviousValuesPromise
  extends Promise<TrainingPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  createdAt: () => Promise<DateTimeOutput>;
  trainingDate: () => Promise<DateTimeOutput>;
  location: () => Promise<String>;
  attendance: () => Promise<Int>;
  published: () => Promise<Boolean>;
}

export interface TrainingPreviousValuesSubscription
  extends Promise<AsyncIterator<TrainingPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  trainingDate: () => Promise<AsyncIterator<DateTimeOutput>>;
  location: () => Promise<AsyncIterator<String>>;
  attendance: () => Promise<AsyncIterator<Int>>;
  published: () => Promise<AsyncIterator<Boolean>>;
}

export interface TrainingTypeSubscriptionPayload {
  mutation: MutationType;
  node: TrainingType;
  updatedFields: String[];
  previousValues: TrainingTypePreviousValues;
}

export interface TrainingTypeSubscriptionPayloadPromise
  extends Promise<TrainingTypeSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = TrainingTypePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = TrainingTypePreviousValuesPromise>() => T;
}

export interface TrainingTypeSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<TrainingTypeSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = TrainingTypeSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = TrainingTypePreviousValuesSubscription>() => T;
}

export interface TrainingTypePreviousValues {
  id: ID_Output;
  name: String;
  description: String;
}

export interface TrainingTypePreviousValuesPromise
  extends Promise<TrainingTypePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
}

export interface TrainingTypePreviousValuesSubscription
  extends Promise<AsyncIterator<TrainingTypePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
}

export interface UserSubscriptionPayload {
  mutation: MutationType;
  node: User;
  updatedFields: String[];
  previousValues: UserPreviousValues;
}

export interface UserSubscriptionPayloadPromise
  extends Promise<UserSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = UserPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = UserPreviousValuesPromise>() => T;
}

export interface UserSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<UserSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = UserSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = UserPreviousValuesSubscription>() => T;
}

export interface UserPreviousValues {
  id: ID_Output;
  email: String;
  name: String;
  password: String;
  resetToken?: String;
  resetTokenExpiry?: Float;
  createdAt: DateTimeOutput;
  permissions: Permission[];
  interests: String[];
}

export interface UserPreviousValuesPromise
  extends Promise<UserPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  email: () => Promise<String>;
  name: () => Promise<String>;
  password: () => Promise<String>;
  resetToken: () => Promise<String>;
  resetTokenExpiry: () => Promise<Float>;
  createdAt: () => Promise<DateTimeOutput>;
  permissions: () => Promise<Permission[]>;
  interests: () => Promise<String[]>;
}

export interface UserPreviousValuesSubscription
  extends Promise<AsyncIterator<UserPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  email: () => Promise<AsyncIterator<String>>;
  name: () => Promise<AsyncIterator<String>>;
  password: () => Promise<AsyncIterator<String>>;
  resetToken: () => Promise<AsyncIterator<String>>;
  resetTokenExpiry: () => Promise<AsyncIterator<Float>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  permissions: () => Promise<AsyncIterator<Permission[]>>;
  interests: () => Promise<AsyncIterator<String[]>>;
}

export interface VideoSubscriptionPayload {
  mutation: MutationType;
  node: Video;
  updatedFields: String[];
  previousValues: VideoPreviousValues;
}

export interface VideoSubscriptionPayloadPromise
  extends Promise<VideoSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = VideoPromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = VideoPreviousValuesPromise>() => T;
}

export interface VideoSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<VideoSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = VideoSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = VideoPreviousValuesSubscription>() => T;
}

export interface VideoPreviousValues {
  id: ID_Output;
  createdAt: DateTimeOutput;
  updatedAt: DateTimeOutput;
  order: Int;
}

export interface VideoPreviousValuesPromise
  extends Promise<VideoPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  createdAt: () => Promise<DateTimeOutput>;
  updatedAt: () => Promise<DateTimeOutput>;
  order: () => Promise<Int>;
}

export interface VideoPreviousValuesSubscription
  extends Promise<AsyncIterator<VideoPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  updatedAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  order: () => Promise<AsyncIterator<Int>>;
}

/*
The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.
*/
export type ID_Input = string | number;
export type ID_Output = string;

/*
The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
*/
export type String = string;

/*
The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
*/
export type Int = number;

/*
DateTime scalar input type, allowing Date
*/
export type DateTimeInput = Date | string;

/*
DateTime scalar output type, which is always a string
*/
export type DateTimeOutput = string;

/*
The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).
*/
export type Float = number;

/*
The `Boolean` scalar type represents `true` or `false`.
*/
export type Boolean = boolean;

export type Long = string;

/**
 * Model Metadata
 */

export const models: Model[] = [
  {
    name: "User",
    embedded: false
  },
  {
    name: "Permission",
    embedded: false
  },
  {
    name: "Training",
    embedded: false
  },
  {
    name: "TrainingType",
    embedded: false
  },
  {
    name: "Block",
    embedded: false
  },
  {
    name: "BlockInstance",
    embedded: false
  },
  {
    name: "Format",
    embedded: false
  },
  {
    name: "Picture",
    embedded: false
  },
  {
    name: "Video",
    embedded: false
  },
  {
    name: "Track",
    embedded: false
  },
  {
    name: "File",
    embedded: false
  },
  {
    name: "Link",
    embedded: false
  },
  {
    name: "Exercise",
    embedded: false
  },
  {
    name: "ExerciseInstance",
    embedded: false
  },
  {
    name: "Rating",
    embedded: false
  },
  {
    name: "Comment",
    embedded: false
  }
];

/**
 * Type Defs
 */

export const Prisma = makePrismaClientClass<ClientConstructor<Prisma>>({
  typeDefs,
  models,
  endpoint: `http://prisma:4466`,
  secret: `PrismaSecret`
});
export const prisma = new Prisma();