u-fit/backend/database/generated/prisma-client/index.d.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 {
  baseExercise: (where?: BaseExerciseWhereInput) => Promise<boolean>;
  block: (where?: BlockWhereInput) => Promise<boolean>;
  comment: (where?: CommentWhereInput) => Promise<boolean>;
  exercise: (where?: ExerciseWhereInput) => Promise<boolean>;
  format: (where?: FormatWhereInput) => 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>;
}

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
   */

  baseExercise: (
    where: BaseExerciseWhereUniqueInput
  ) => BaseExerciseNullablePromise;
  baseExercises: (args?: {
    where?: BaseExerciseWhereInput;
    orderBy?: BaseExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => FragmentableArray<BaseExercise>;
  baseExercisesConnection: (args?: {
    where?: BaseExerciseWhereInput;
    orderBy?: BaseExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => BaseExerciseConnectionPromise;
  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;
  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;
  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;
  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;
  node: (args: { id: ID_Output }) => Node;

  /**
   * Mutations
   */

  createBaseExercise: (data: BaseExerciseCreateInput) => BaseExercisePromise;
  updateBaseExercise: (args: {
    data: BaseExerciseUpdateInput;
    where: BaseExerciseWhereUniqueInput;
  }) => BaseExercisePromise;
  updateManyBaseExercises: (args: {
    data: BaseExerciseUpdateManyMutationInput;
    where?: BaseExerciseWhereInput;
  }) => BatchPayloadPromise;
  upsertBaseExercise: (args: {
    where: BaseExerciseWhereUniqueInput;
    create: BaseExerciseCreateInput;
    update: BaseExerciseUpdateInput;
  }) => BaseExercisePromise;
  deleteBaseExercise: (
    where: BaseExerciseWhereUniqueInput
  ) => BaseExercisePromise;
  deleteManyBaseExercises: (
    where?: BaseExerciseWhereInput
  ) => BatchPayloadPromise;
  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;
  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;
  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;
  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;

  /**
   * Subscriptions
   */

  $subscribe: Subscription;
}

export interface Subscription {
  baseExercise: (
    where?: BaseExerciseSubscriptionWhereInput
  ) => BaseExerciseSubscriptionPayloadSubscription;
  block: (
    where?: BlockSubscriptionWhereInput
  ) => BlockSubscriptionPayloadSubscription;
  comment: (
    where?: CommentSubscriptionWhereInput
  ) => CommentSubscriptionPayloadSubscription;
  exercise: (
    where?: ExerciseSubscriptionWhereInput
  ) => ExerciseSubscriptionPayloadSubscription;
  format: (
    where?: FormatSubscriptionWhereInput
  ) => FormatSubscriptionPayloadSubscription;
  rating: (
    where?: RatingSubscriptionWhereInput
  ) => RatingSubscriptionPayloadSubscription;
  track: (
    where?: TrackSubscriptionWhereInput
  ) => TrackSubscriptionPayloadSubscription;
  training: (
    where?: TrainingSubscriptionWhereInput
  ) => TrainingSubscriptionPayloadSubscription;
  trainingType: (
    where?: TrainingTypeSubscriptionWhereInput
  ) => TrainingTypeSubscriptionPayloadSubscription;
  user: (
    where?: UserSubscriptionWhereInput
  ) => UserSubscriptionPayloadSubscription;
}

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

/**
 * Types
 */

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

export type BaseExerciseOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "name_ASC"
  | "name_DESC";

export type TrackOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "title_ASC"
  | "title_DESC"
  | "artist_ASC"
  | "artist_DESC"
  | "duration_ASC"
  | "duration_DESC"
  | "link_ASC"
  | "link_DESC";

export type BlockOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "sequence_ASC"
  | "sequence_DESC"
  | "title_ASC"
  | "title_DESC"
  | "duration_ASC"
  | "duration_DESC"
  | "variation_ASC"
  | "variation_DESC"
  | "description_ASC"
  | "description_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" | "USER";

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

export type UserOrderByInput =
  | "id_ASC"
  | "id_DESC"
  | "email_ASC"
  | "email_DESC"
  | "name_ASC"
  | "name_DESC"
  | "password_ASC"
  | "password_DESC"
  | "createdAt_ASC"
  | "createdAt_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 BaseExerciseWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

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>;
  video?: Maybe<String>;
  video_not?: Maybe<String>;
  video_in?: Maybe<String[] | String>;
  video_not_in?: Maybe<String[] | String>;
  video_lt?: Maybe<String>;
  video_lte?: Maybe<String>;
  video_gt?: Maybe<String>;
  video_gte?: Maybe<String>;
  video_contains?: Maybe<String>;
  video_not_contains?: Maybe<String>;
  video_starts_with?: Maybe<String>;
  video_not_starts_with?: Maybe<String>;
  video_ends_with?: Maybe<String>;
  video_not_ends_with?: Maybe<String>;
  baseExercise?: Maybe<BaseExerciseWhereInput>;
  AND?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
  OR?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
  NOT?: Maybe<ExerciseWhereInput[] | ExerciseWhereInput>;
}

export interface BaseExerciseWhereInput {
  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>;
  variations_every?: Maybe<ExerciseWhereInput>;
  variations_some?: Maybe<ExerciseWhereInput>;
  variations_none?: Maybe<ExerciseWhereInput>;
  AND?: Maybe<BaseExerciseWhereInput[] | BaseExerciseWhereInput>;
  OR?: Maybe<BaseExerciseWhereInput[] | BaseExerciseWhereInput>;
  NOT?: Maybe<BaseExerciseWhereInput[] | BaseExerciseWhereInput>;
}

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>;
  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>;
  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>;
  link?: Maybe<String>;
  link_not?: Maybe<String>;
  link_in?: Maybe<String[] | String>;
  link_not_in?: Maybe<String[] | String>;
  link_lt?: Maybe<String>;
  link_lte?: Maybe<String>;
  link_gt?: Maybe<String>;
  link_gte?: Maybe<String>;
  link_contains?: Maybe<String>;
  link_not_contains?: Maybe<String>;
  link_starts_with?: Maybe<String>;
  link_not_starts_with?: Maybe<String>;
  link_ends_with?: Maybe<String>;
  link_not_ends_with?: Maybe<String>;
  AND?: Maybe<TrackWhereInput[] | TrackWhereInput>;
  OR?: Maybe<TrackWhereInput[] | TrackWhereInput>;
  NOT?: Maybe<TrackWhereInput[] | TrackWhereInput>;
}

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>;
  sequence?: Maybe<Int>;
  sequence_not?: Maybe<Int>;
  sequence_in?: Maybe<Int[] | Int>;
  sequence_not_in?: Maybe<Int[] | Int>;
  sequence_lt?: Maybe<Int>;
  sequence_lte?: Maybe<Int>;
  sequence_gt?: Maybe<Int>;
  sequence_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>;
  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>;
  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>;
  format?: Maybe<FormatWhereInput>;
  tracks_every?: Maybe<TrackWhereInput>;
  tracks_some?: Maybe<TrackWhereInput>;
  tracks_none?: Maybe<TrackWhereInput>;
  exercises_every?: Maybe<ExerciseWhereInput>;
  exercises_some?: Maybe<ExerciseWhereInput>;
  exercises_none?: Maybe<ExerciseWhereInput>;
  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<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 type CommentWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

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 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>;
  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 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 type ExerciseWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

export type FormatWhereUniqueInput = 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 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>;
  content_every?: Maybe<BlockWhereInput>;
  content_some?: Maybe<BlockWhereInput>;
  content_none?: Maybe<BlockWhereInput>;
  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>;
  registration_every?: Maybe<UserWhereInput>;
  registration_some?: Maybe<UserWhereInput>;
  registration_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>;
  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 TrainingTypeWhereUniqueInput = AtLeastOne<{
  id: Maybe<ID_Input>;
}>;

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

export interface BaseExerciseCreateInput {
  id?: Maybe<ID_Input>;
  name: String;
  variations?: Maybe<ExerciseCreateManyWithoutBaseExerciseInput>;
}

export interface ExerciseCreateManyWithoutBaseExerciseInput {
  create?: Maybe<
    | ExerciseCreateWithoutBaseExerciseInput[]
    | ExerciseCreateWithoutBaseExerciseInput
  >;
  connect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
}

export interface ExerciseCreateWithoutBaseExerciseInput {
  id?: Maybe<ID_Input>;
  name: String;
  description: String;
  video: String;
  targets?: Maybe<ExerciseCreatetargetsInput>;
}

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

export interface BaseExerciseUpdateInput {
  name?: Maybe<String>;
  variations?: Maybe<ExerciseUpdateManyWithoutBaseExerciseInput>;
}

export interface ExerciseUpdateManyWithoutBaseExerciseInput {
  create?: Maybe<
    | ExerciseCreateWithoutBaseExerciseInput[]
    | ExerciseCreateWithoutBaseExerciseInput
  >;
  delete?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  connect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  set?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  disconnect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  update?: Maybe<
    | ExerciseUpdateWithWhereUniqueWithoutBaseExerciseInput[]
    | ExerciseUpdateWithWhereUniqueWithoutBaseExerciseInput
  >;
  upsert?: Maybe<
    | ExerciseUpsertWithWhereUniqueWithoutBaseExerciseInput[]
    | ExerciseUpsertWithWhereUniqueWithoutBaseExerciseInput
  >;
  deleteMany?: Maybe<ExerciseScalarWhereInput[] | ExerciseScalarWhereInput>;
  updateMany?: Maybe<
    | ExerciseUpdateManyWithWhereNestedInput[]
    | ExerciseUpdateManyWithWhereNestedInput
  >;
}

export interface ExerciseUpdateWithWhereUniqueWithoutBaseExerciseInput {
  where: ExerciseWhereUniqueInput;
  data: ExerciseUpdateWithoutBaseExerciseDataInput;
}

export interface ExerciseUpdateWithoutBaseExerciseDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  video?: Maybe<String>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
}

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

export interface ExerciseUpsertWithWhereUniqueWithoutBaseExerciseInput {
  where: ExerciseWhereUniqueInput;
  update: ExerciseUpdateWithoutBaseExerciseDataInput;
  create: ExerciseCreateWithoutBaseExerciseInput;
}

export interface ExerciseScalarWhereInput {
  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>;
  video?: Maybe<String>;
  video_not?: Maybe<String>;
  video_in?: Maybe<String[] | String>;
  video_not_in?: Maybe<String[] | String>;
  video_lt?: Maybe<String>;
  video_lte?: Maybe<String>;
  video_gt?: Maybe<String>;
  video_gte?: Maybe<String>;
  video_contains?: Maybe<String>;
  video_not_contains?: Maybe<String>;
  video_starts_with?: Maybe<String>;
  video_not_starts_with?: Maybe<String>;
  video_ends_with?: Maybe<String>;
  video_not_ends_with?: Maybe<String>;
  AND?: Maybe<ExerciseScalarWhereInput[] | ExerciseScalarWhereInput>;
  OR?: Maybe<ExerciseScalarWhereInput[] | ExerciseScalarWhereInput>;
  NOT?: Maybe<ExerciseScalarWhereInput[] | ExerciseScalarWhereInput>;
}

export interface ExerciseUpdateManyWithWhereNestedInput {
  where: ExerciseScalarWhereInput;
  data: ExerciseUpdateManyDataInput;
}

export interface ExerciseUpdateManyDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  video?: Maybe<String>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
}

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

export interface BlockCreateInput {
  id?: Maybe<ID_Input>;
  sequence: Int;
  title: String;
  duration: Int;
  variation?: Maybe<String>;
  format?: Maybe<FormatCreateOneInput>;
  tracks?: Maybe<TrackCreateManyInput>;
  exercises?: Maybe<ExerciseCreateManyInput>;
  description: String;
}

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>;
  title: String;
  artist: String;
  duration: Int;
  link: String;
}

export interface ExerciseCreateManyInput {
  create?: Maybe<ExerciseCreateInput[] | ExerciseCreateInput>;
  connect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
}

export interface ExerciseCreateInput {
  id?: Maybe<ID_Input>;
  name: String;
  description: String;
  video: String;
  targets?: Maybe<ExerciseCreatetargetsInput>;
  baseExercise: BaseExerciseCreateOneWithoutVariationsInput;
}

export interface BaseExerciseCreateOneWithoutVariationsInput {
  create?: Maybe<BaseExerciseCreateWithoutVariationsInput>;
  connect?: Maybe<BaseExerciseWhereUniqueInput>;
}

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

export interface BlockUpdateInput {
  sequence?: Maybe<Int>;
  title?: Maybe<String>;
  duration?: Maybe<Int>;
  variation?: Maybe<String>;
  format?: Maybe<FormatUpdateOneInput>;
  tracks?: Maybe<TrackUpdateManyInput>;
  exercises?: Maybe<ExerciseUpdateManyInput>;
  description?: Maybe<String>;
}

export interface FormatUpdateOneInput {
  create?: Maybe<FormatCreateInput>;
  update?: Maybe<FormatUpdateDataInput>;
  upsert?: Maybe<FormatUpsertNestedInput>;
  delete?: Maybe<Boolean>;
  disconnect?: Maybe<Boolean>;
  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 {
  title?: Maybe<String>;
  artist?: Maybe<String>;
  duration?: Maybe<Int>;
  link?: Maybe<String>;
}

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>;
  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>;
  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>;
  link?: Maybe<String>;
  link_not?: Maybe<String>;
  link_in?: Maybe<String[] | String>;
  link_not_in?: Maybe<String[] | String>;
  link_lt?: Maybe<String>;
  link_lte?: Maybe<String>;
  link_gt?: Maybe<String>;
  link_gte?: Maybe<String>;
  link_contains?: Maybe<String>;
  link_not_contains?: Maybe<String>;
  link_starts_with?: Maybe<String>;
  link_not_starts_with?: Maybe<String>;
  link_ends_with?: Maybe<String>;
  link_not_ends_with?: Maybe<String>;
  AND?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
  OR?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
  NOT?: Maybe<TrackScalarWhereInput[] | TrackScalarWhereInput>;
}

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

export interface TrackUpdateManyDataInput {
  title?: Maybe<String>;
  artist?: Maybe<String>;
  duration?: Maybe<Int>;
  link?: Maybe<String>;
}

export interface ExerciseUpdateManyInput {
  create?: Maybe<ExerciseCreateInput[] | ExerciseCreateInput>;
  update?: Maybe<
    | ExerciseUpdateWithWhereUniqueNestedInput[]
    | ExerciseUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | ExerciseUpsertWithWhereUniqueNestedInput[]
    | ExerciseUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  connect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  set?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  disconnect?: Maybe<ExerciseWhereUniqueInput[] | ExerciseWhereUniqueInput>;
  deleteMany?: Maybe<ExerciseScalarWhereInput[] | ExerciseScalarWhereInput>;
  updateMany?: Maybe<
    | ExerciseUpdateManyWithWhereNestedInput[]
    | ExerciseUpdateManyWithWhereNestedInput
  >;
}

export interface ExerciseUpdateWithWhereUniqueNestedInput {
  where: ExerciseWhereUniqueInput;
  data: ExerciseUpdateDataInput;
}

export interface ExerciseUpdateDataInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  video?: Maybe<String>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
  baseExercise?: Maybe<BaseExerciseUpdateOneRequiredWithoutVariationsInput>;
}

export interface BaseExerciseUpdateOneRequiredWithoutVariationsInput {
  create?: Maybe<BaseExerciseCreateWithoutVariationsInput>;
  update?: Maybe<BaseExerciseUpdateWithoutVariationsDataInput>;
  upsert?: Maybe<BaseExerciseUpsertWithoutVariationsInput>;
  connect?: Maybe<BaseExerciseWhereUniqueInput>;
}

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

export interface BaseExerciseUpsertWithoutVariationsInput {
  update: BaseExerciseUpdateWithoutVariationsDataInput;
  create: BaseExerciseCreateWithoutVariationsInput;
}

export interface ExerciseUpsertWithWhereUniqueNestedInput {
  where: ExerciseWhereUniqueInput;
  update: ExerciseUpdateDataInput;
  create: ExerciseCreateInput;
}

export interface BlockUpdateManyMutationInput {
  sequence?: Maybe<Int>;
  title?: Maybe<String>;
  duration?: Maybe<Int>;
  variation?: Maybe<String>;
  description?: 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;
  ratings?: Maybe<RatingCreateManyWithoutUserInput>;
  permissions?: Maybe<UserCreatepermissionsInput>;
  interests?: Maybe<UserCreateinterestsInput>;
}

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 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>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

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 UserUpsertWithoutCommentsInput {
  update: UserUpdateWithoutCommentsDataInput;
  create: UserCreateWithoutCommentsInput;
}

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

export interface ExerciseUpdateInput {
  name?: Maybe<String>;
  description?: Maybe<String>;
  video?: Maybe<String>;
  targets?: Maybe<ExerciseUpdatetargetsInput>;
  baseExercise?: Maybe<BaseExerciseUpdateOneRequiredWithoutVariationsInput>;
}

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

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

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

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;
  comments?: Maybe<CommentCreateManyWithoutAuthorInput>;
  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 RatingUpdateInput {
  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>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  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 UserUpsertWithoutRatingsInput {
  update: UserUpdateWithoutRatingsDataInput;
  create: UserCreateWithoutRatingsInput;
}

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

export interface TrackUpdateInput {
  title?: Maybe<String>;
  artist?: Maybe<String>;
  duration?: Maybe<Int>;
  link?: Maybe<String>;
}

export interface TrackUpdateManyMutationInput {
  title?: Maybe<String>;
  artist?: Maybe<String>;
  duration?: Maybe<Int>;
  link?: Maybe<String>;
}

export interface TrainingCreateInput {
  id?: Maybe<ID_Input>;
  title: String;
  type: TrainingTypeCreateOneInput;
  content?: Maybe<BlockCreateManyInput>;
  trainingDate: DateTimeInput;
  location: String;
  registration?: Maybe<UserCreateManyInput>;
  attendance: 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 BlockCreateManyInput {
  create?: Maybe<BlockCreateInput[] | BlockCreateInput>;
  connect?: Maybe<BlockWhereUniqueInput[] | BlockWhereUniqueInput>;
}

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

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

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

export interface TrainingUpdateInput {
  title?: Maybe<String>;
  type?: Maybe<TrainingTypeUpdateOneRequiredInput>;
  content?: Maybe<BlockUpdateManyInput>;
  trainingDate?: Maybe<DateTimeInput>;
  location?: Maybe<String>;
  registration?: 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 BlockUpdateManyInput {
  create?: Maybe<BlockCreateInput[] | BlockCreateInput>;
  update?: Maybe<
    | BlockUpdateWithWhereUniqueNestedInput[]
    | BlockUpdateWithWhereUniqueNestedInput
  >;
  upsert?: Maybe<
    | BlockUpsertWithWhereUniqueNestedInput[]
    | BlockUpsertWithWhereUniqueNestedInput
  >;
  delete?: Maybe<BlockWhereUniqueInput[] | BlockWhereUniqueInput>;
  connect?: Maybe<BlockWhereUniqueInput[] | BlockWhereUniqueInput>;
  set?: Maybe<BlockWhereUniqueInput[] | BlockWhereUniqueInput>;
  disconnect?: Maybe<BlockWhereUniqueInput[] | BlockWhereUniqueInput>;
  deleteMany?: Maybe<BlockScalarWhereInput[] | BlockScalarWhereInput>;
  updateMany?: Maybe<
    BlockUpdateManyWithWhereNestedInput[] | BlockUpdateManyWithWhereNestedInput
  >;
}

export interface BlockUpdateWithWhereUniqueNestedInput {
  where: BlockWhereUniqueInput;
  data: BlockUpdateDataInput;
}

export interface BlockUpdateDataInput {
  sequence?: Maybe<Int>;
  title?: Maybe<String>;
  duration?: Maybe<Int>;
  variation?: Maybe<String>;
  format?: Maybe<FormatUpdateOneInput>;
  tracks?: Maybe<TrackUpdateManyInput>;
  exercises?: Maybe<ExerciseUpdateManyInput>;
  description?: Maybe<String>;
}

export interface BlockUpsertWithWhereUniqueNestedInput {
  where: BlockWhereUniqueInput;
  update: BlockUpdateDataInput;
  create: BlockCreateInput;
}

export interface BlockScalarWhereInput {
  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>;
  sequence?: Maybe<Int>;
  sequence_not?: Maybe<Int>;
  sequence_in?: Maybe<Int[] | Int>;
  sequence_not_in?: Maybe<Int[] | Int>;
  sequence_lt?: Maybe<Int>;
  sequence_lte?: Maybe<Int>;
  sequence_gt?: Maybe<Int>;
  sequence_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>;
  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>;
  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>;
  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<BlockScalarWhereInput[] | BlockScalarWhereInput>;
  OR?: Maybe<BlockScalarWhereInput[] | BlockScalarWhereInput>;
  NOT?: Maybe<BlockScalarWhereInput[] | BlockScalarWhereInput>;
}

export interface BlockUpdateManyWithWhereNestedInput {
  where: BlockScalarWhereInput;
  data: BlockUpdateManyDataInput;
}

export interface BlockUpdateManyDataInput {
  sequence?: Maybe<Int>;
  title?: Maybe<String>;
  duration?: Maybe<Int>;
  variation?: Maybe<String>;
  description?: Maybe<String>;
}

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 UserUpdateDataInput {
  email?: Maybe<String>;
  name?: Maybe<String>;
  password?: Maybe<String>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

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>;
  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>;
  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 RatingUpsertWithWhereUniqueNestedInput {
  where: RatingWhereUniqueInput;
  update: RatingUpdateDataInput;
  create: RatingCreateInput;
}

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>;
  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
  permissions?: Maybe<UserUpdatepermissionsInput>;
  interests?: Maybe<UserUpdateinterestsInput>;
}

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

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

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 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 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 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 NodeNode {
  id: ID_Output;
}

export interface BaseExercise {
  id: ID_Output;
  name: String;
}

export interface BaseExercisePromise
  extends Promise<BaseExercise>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  variations: <T = FragmentableArray<Exercise>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface BaseExerciseSubscription
  extends Promise<AsyncIterator<BaseExercise>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  variations: <T = Promise<AsyncIterator<ExerciseSubscription>>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

export interface BaseExerciseNullablePromise
  extends Promise<BaseExercise | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  variations: <T = FragmentableArray<Exercise>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
}

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

export interface ExercisePromise extends Promise<Exercise>, Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  video: () => Promise<String>;
  targets: () => Promise<String[]>;
  baseExercise: <T = BaseExercisePromise>() => T;
}

export interface ExerciseSubscription
  extends Promise<AsyncIterator<Exercise>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  video: () => Promise<AsyncIterator<String>>;
  targets: () => Promise<AsyncIterator<String[]>>;
  baseExercise: <T = BaseExerciseSubscription>() => T;
}

export interface ExerciseNullablePromise
  extends Promise<Exercise | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
  description: () => Promise<String>;
  video: () => Promise<String>;
  targets: () => Promise<String[]>;
  baseExercise: <T = BaseExercisePromise>() => T;
}

export interface BaseExerciseConnection {
  pageInfo: PageInfo;
  edges: BaseExerciseEdge[];
}

export interface BaseExerciseConnectionPromise
  extends Promise<BaseExerciseConnection>,
    Fragmentable {
  pageInfo: <T = PageInfoPromise>() => T;
  edges: <T = FragmentableArray<BaseExerciseEdge>>() => T;
  aggregate: <T = AggregateBaseExercisePromise>() => T;
}

export interface BaseExerciseConnectionSubscription
  extends Promise<AsyncIterator<BaseExerciseConnection>>,
    Fragmentable {
  pageInfo: <T = PageInfoSubscription>() => T;
  edges: <T = Promise<AsyncIterator<BaseExerciseEdgeSubscription>>>() => T;
  aggregate: <T = AggregateBaseExerciseSubscription>() => 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 BaseExerciseEdge {
  node: BaseExercise;
  cursor: String;
}

export interface BaseExerciseEdgePromise
  extends Promise<BaseExerciseEdge>,
    Fragmentable {
  node: <T = BaseExercisePromise>() => T;
  cursor: () => Promise<String>;
}

export interface BaseExerciseEdgeSubscription
  extends Promise<AsyncIterator<BaseExerciseEdge>>,
    Fragmentable {
  node: <T = BaseExerciseSubscription>() => T;
  cursor: () => Promise<AsyncIterator<String>>;
}

export interface AggregateBaseExercise {
  count: Int;
}

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

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

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

export interface BlockPromise extends Promise<Block>, Fragmentable {
  id: () => Promise<ID_Output>;
  sequence: () => Promise<Int>;
  title: () => Promise<String>;
  duration: () => Promise<Int>;
  variation: () => Promise<String>;
  format: <T = FormatPromise>() => T;
  tracks: <T = FragmentableArray<Track>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = FragmentableArray<Exercise>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  description: () => Promise<String>;
}

export interface BlockSubscription
  extends Promise<AsyncIterator<Block>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  sequence: () => Promise<AsyncIterator<Int>>;
  title: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
  format: <T = FormatSubscription>() => T;
  tracks: <T = Promise<AsyncIterator<TrackSubscription>>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = Promise<AsyncIterator<ExerciseSubscription>>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  description: () => Promise<AsyncIterator<String>>;
}

export interface BlockNullablePromise
  extends Promise<Block | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  sequence: () => Promise<Int>;
  title: () => Promise<String>;
  duration: () => Promise<Int>;
  variation: () => Promise<String>;
  format: <T = FormatPromise>() => T;
  tracks: <T = FragmentableArray<Track>>(args?: {
    where?: TrackWhereInput;
    orderBy?: TrackOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  exercises: <T = FragmentableArray<Exercise>>(args?: {
    where?: ExerciseWhereInput;
    orderBy?: ExerciseOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  description: () => Promise<String>;
}

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;
  title: String;
  artist: String;
  duration: Int;
  link: String;
}

export interface TrackPromise extends Promise<Track>, Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
  duration: () => Promise<Int>;
  link: () => Promise<String>;
}

export interface TrackSubscription
  extends Promise<AsyncIterator<Track>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  link: () => Promise<AsyncIterator<String>>;
}

export interface TrackNullablePromise
  extends Promise<Track | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
  duration: () => Promise<Int>;
  link: () => Promise<String>;
}

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 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 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 User {
  id: ID_Output;
  email: String;
  name: String;
  password: String;
  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>;
  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>>;
  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>;
  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 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 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 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 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 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;
  content: <T = FragmentableArray<Block>>(args?: {
    where?: BlockWhereInput;
    orderBy?: BlockOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  createdAt: () => Promise<DateTimeOutput>;
  trainingDate: () => Promise<DateTimeOutput>;
  location: () => Promise<String>;
  registration: <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>;
}

export interface TrainingSubscription
  extends Promise<AsyncIterator<Training>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  type: <T = TrainingTypeSubscription>() => T;
  content: <T = Promise<AsyncIterator<BlockSubscription>>>(args?: {
    where?: BlockWhereInput;
    orderBy?: BlockOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  trainingDate: () => Promise<AsyncIterator<DateTimeOutput>>;
  location: () => Promise<AsyncIterator<String>>;
  registration: <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>>;
}

export interface TrainingNullablePromise
  extends Promise<Training | null>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  type: <T = TrainingTypePromise>() => T;
  content: <T = FragmentableArray<Block>>(args?: {
    where?: BlockWhereInput;
    orderBy?: BlockOrderByInput;
    skip?: Int;
    after?: String;
    before?: String;
    first?: Int;
    last?: Int;
  }) => T;
  createdAt: () => Promise<DateTimeOutput>;
  trainingDate: () => Promise<DateTimeOutput>;
  location: () => Promise<String>;
  registration: <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>;
}

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 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 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 BaseExerciseSubscriptionPayload {
  mutation: MutationType;
  node: BaseExercise;
  updatedFields: String[];
  previousValues: BaseExercisePreviousValues;
}

export interface BaseExerciseSubscriptionPayloadPromise
  extends Promise<BaseExerciseSubscriptionPayload>,
    Fragmentable {
  mutation: () => Promise<MutationType>;
  node: <T = BaseExercisePromise>() => T;
  updatedFields: () => Promise<String[]>;
  previousValues: <T = BaseExercisePreviousValuesPromise>() => T;
}

export interface BaseExerciseSubscriptionPayloadSubscription
  extends Promise<AsyncIterator<BaseExerciseSubscriptionPayload>>,
    Fragmentable {
  mutation: () => Promise<AsyncIterator<MutationType>>;
  node: <T = BaseExerciseSubscription>() => T;
  updatedFields: () => Promise<AsyncIterator<String[]>>;
  previousValues: <T = BaseExercisePreviousValuesSubscription>() => T;
}

export interface BaseExercisePreviousValues {
  id: ID_Output;
  name: String;
}

export interface BaseExercisePreviousValuesPromise
  extends Promise<BaseExercisePreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  name: () => Promise<String>;
}

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

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;
  sequence: Int;
  title: String;
  duration: Int;
  variation?: String;
  description: String;
}

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

export interface BlockPreviousValuesSubscription
  extends Promise<AsyncIterator<BlockPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  sequence: () => Promise<AsyncIterator<Int>>;
  title: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  variation: () => Promise<AsyncIterator<String>>;
  description: () => 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;
  video: String;
  targets: String[];
}

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

export interface ExercisePreviousValuesSubscription
  extends Promise<AsyncIterator<ExercisePreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  name: () => Promise<AsyncIterator<String>>;
  description: () => Promise<AsyncIterator<String>>;
  video: () => Promise<AsyncIterator<String>>;
  targets: () => 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 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;
  title: String;
  artist: String;
  duration: Int;
  link: String;
}

export interface TrackPreviousValuesPromise
  extends Promise<TrackPreviousValues>,
    Fragmentable {
  id: () => Promise<ID_Output>;
  title: () => Promise<String>;
  artist: () => Promise<String>;
  duration: () => Promise<Int>;
  link: () => Promise<String>;
}

export interface TrackPreviousValuesSubscription
  extends Promise<AsyncIterator<TrackPreviousValues>>,
    Fragmentable {
  id: () => Promise<AsyncIterator<ID_Output>>;
  title: () => Promise<AsyncIterator<String>>;
  artist: () => Promise<AsyncIterator<String>>;
  duration: () => Promise<AsyncIterator<Int>>;
  link: () => Promise<AsyncIterator<String>>;
}

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;
  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>;
  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>>;
  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
  permissions: () => Promise<AsyncIterator<Permission[]>>;
  interests: () => Promise<AsyncIterator<String[]>>;
}

/*
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;

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

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

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

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: "Format",
    embedded: false
  },
  {
    name: "Track",
    embedded: false
  },
  {
    name: "Exercise",
    embedded: false
  },
  {
    name: "BaseExercise",
    embedded: false
  },
  {
    name: "Rating",
    embedded: false
  },
  {
    name: "Comment",
    embedded: false
  }
];

/**
 * Type Defs
 */

export const prisma: Prisma;