|  | @@ -0,0 +1,3545 @@
 | 
	
		
			
				|  |  | +// Code generated by Prisma (prisma@1.34.10). DO NOT EDIT.
 | 
	
		
			
				|  |  | +// Please don't change this file manually but run `prisma generate` to update it.
 | 
	
		
			
				|  |  | +// For more information, please read the docs: https://www.prisma.io/docs/prisma-client/
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +import { DocumentNode } from "graphql";
 | 
	
		
			
				|  |  | +import {
 | 
	
		
			
				|  |  | +  makePrismaClientClass,
 | 
	
		
			
				|  |  | +  BaseClientOptions,
 | 
	
		
			
				|  |  | +  Model
 | 
	
		
			
				|  |  | +} from "prisma-client-lib";
 | 
	
		
			
				|  |  | +import { typeDefs } from "./prisma-schema";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type AtLeastOne<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> &
 | 
	
		
			
				|  |  | +  U[keyof U];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type Maybe<T> = T | undefined | null;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface Exists {
 | 
	
		
			
				|  |  | +  block: (where?: BlockWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  comment: (where?: CommentWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  excersise: (where?: ExcersiseWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  format: (where?: FormatWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  rating: (where?: RatingWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  track: (where?: TrackWhereInput) => Promise<boolean>;
 | 
	
		
			
				|  |  | +  training: (where?: TrainingWhereInput) => 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
 | 
	
		
			
				|  |  | +   */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  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;
 | 
	
		
			
				|  |  | +  excersise: (where: ExcersiseWhereUniqueInput) => ExcersiseNullablePromise;
 | 
	
		
			
				|  |  | +  excersises: (args?: {
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: ExcersiseOrderByInput;
 | 
	
		
			
				|  |  | +    skip?: Int;
 | 
	
		
			
				|  |  | +    after?: String;
 | 
	
		
			
				|  |  | +    before?: String;
 | 
	
		
			
				|  |  | +    first?: Int;
 | 
	
		
			
				|  |  | +    last?: Int;
 | 
	
		
			
				|  |  | +  }) => FragmentableArray<Excersise>;
 | 
	
		
			
				|  |  | +  excersisesConnection: (args?: {
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: ExcersiseOrderByInput;
 | 
	
		
			
				|  |  | +    skip?: Int;
 | 
	
		
			
				|  |  | +    after?: String;
 | 
	
		
			
				|  |  | +    before?: String;
 | 
	
		
			
				|  |  | +    first?: Int;
 | 
	
		
			
				|  |  | +    last?: Int;
 | 
	
		
			
				|  |  | +  }) => ExcersiseConnectionPromise;
 | 
	
		
			
				|  |  | +  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;
 | 
	
		
			
				|  |  | +  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
 | 
	
		
			
				|  |  | +   */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  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;
 | 
	
		
			
				|  |  | +  createExcersise: (data: ExcersiseCreateInput) => ExcersisePromise;
 | 
	
		
			
				|  |  | +  updateExcersise: (args: {
 | 
	
		
			
				|  |  | +    data: ExcersiseUpdateInput;
 | 
	
		
			
				|  |  | +    where: ExcersiseWhereUniqueInput;
 | 
	
		
			
				|  |  | +  }) => ExcersisePromise;
 | 
	
		
			
				|  |  | +  updateManyExcersises: (args: {
 | 
	
		
			
				|  |  | +    data: ExcersiseUpdateManyMutationInput;
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +  }) => BatchPayloadPromise;
 | 
	
		
			
				|  |  | +  upsertExcersise: (args: {
 | 
	
		
			
				|  |  | +    where: ExcersiseWhereUniqueInput;
 | 
	
		
			
				|  |  | +    create: ExcersiseCreateInput;
 | 
	
		
			
				|  |  | +    update: ExcersiseUpdateInput;
 | 
	
		
			
				|  |  | +  }) => ExcersisePromise;
 | 
	
		
			
				|  |  | +  deleteExcersise: (where: ExcersiseWhereUniqueInput) => ExcersisePromise;
 | 
	
		
			
				|  |  | +  deleteManyExcersises: (where?: ExcersiseWhereInput) => 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;
 | 
	
		
			
				|  |  | +  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 {
 | 
	
		
			
				|  |  | +  block: (
 | 
	
		
			
				|  |  | +    where?: BlockSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => BlockSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  comment: (
 | 
	
		
			
				|  |  | +    where?: CommentSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => CommentSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  excersise: (
 | 
	
		
			
				|  |  | +    where?: ExcersiseSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => ExcersiseSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  format: (
 | 
	
		
			
				|  |  | +    where?: FormatSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => FormatSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  rating: (
 | 
	
		
			
				|  |  | +    where?: RatingSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => RatingSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  track: (
 | 
	
		
			
				|  |  | +    where?: TrackSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => TrackSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  training: (
 | 
	
		
			
				|  |  | +    where?: TrainingSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => TrainingSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +  user: (
 | 
	
		
			
				|  |  | +    where?: UserSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  ) => UserSubscriptionPayloadSubscription;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ClientConstructor<T> {
 | 
	
		
			
				|  |  | +  new (options?: BaseClientOptions): T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * Types
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseOrderByInput =
 | 
	
		
			
				|  |  | +  | "id_ASC"
 | 
	
		
			
				|  |  | +  | "id_DESC"
 | 
	
		
			
				|  |  | +  | "name_ASC"
 | 
	
		
			
				|  |  | +  | "name_DESC"
 | 
	
		
			
				|  |  | +  | "description_ASC"
 | 
	
		
			
				|  |  | +  | "description_DESC"
 | 
	
		
			
				|  |  | +  | "video_ASC"
 | 
	
		
			
				|  |  | +  | "video_DESC";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockOrderByInput =
 | 
	
		
			
				|  |  | +  | "id_ASC"
 | 
	
		
			
				|  |  | +  | "id_DESC"
 | 
	
		
			
				|  |  | +  | "sequence_ASC"
 | 
	
		
			
				|  |  | +  | "sequence_DESC"
 | 
	
		
			
				|  |  | +  | "title_ASC"
 | 
	
		
			
				|  |  | +  | "title_DESC"
 | 
	
		
			
				|  |  | +  | "duration_ASC"
 | 
	
		
			
				|  |  | +  | "duration_DESC"
 | 
	
		
			
				|  |  | +  | "variation_ASC"
 | 
	
		
			
				|  |  | +  | "variation_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 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"
 | 
	
		
			
				|  |  | +  | "abbreviation_ASC"
 | 
	
		
			
				|  |  | +  | "abbreviation_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";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type MutationType = "CREATED" | "UPDATED" | "DELETED";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type BlockWhereUniqueInput = AtLeastOne<{
 | 
	
		
			
				|  |  | +  id: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +}>;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrackWhereInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_not?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_in?: Maybe<ID_Input[] | ID_Input>;
 | 
	
		
			
				|  |  | +  id_not_in?: Maybe<ID_Input[] | ID_Input>;
 | 
	
		
			
				|  |  | +  id_lt?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_lte?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_gt?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_gte?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_contains?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_not_contains?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_starts_with?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_not_starts_with?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_ends_with?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  id_not_ends_with?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  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 ExcersiseWhereInput {
 | 
	
		
			
				|  |  | +  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<ExcersiseWhereInput[] | ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  OR?: Maybe<ExcersiseWhereInput[] | ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  NOT?: Maybe<ExcersiseWhereInput[] | ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  excersises_every?: Maybe<ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  excersises_some?: Maybe<ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  excersises_none?: Maybe<ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_in?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_in?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  abbreviation_lt?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_lte?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_gt?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_gte?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_contains?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_contains?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_starts_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_starts_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_ends_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_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 ExcersiseWhereUniqueInput = 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>;
 | 
	
		
			
				|  |  | +  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>;
 | 
	
		
			
				|  |  | +  participants_every?: Maybe<UserWhereInput>;
 | 
	
		
			
				|  |  | +  participants_some?: Maybe<UserWhereInput>;
 | 
	
		
			
				|  |  | +  participants_none?: Maybe<UserWhereInput>;
 | 
	
		
			
				|  |  | +  ratings_every?: Maybe<RatingWhereInput>;
 | 
	
		
			
				|  |  | +  ratings_some?: Maybe<RatingWhereInput>;
 | 
	
		
			
				|  |  | +  ratings_none?: Maybe<RatingWhereInput>;
 | 
	
		
			
				|  |  | +  AND?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
 | 
	
		
			
				|  |  | +  OR?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
 | 
	
		
			
				|  |  | +  NOT?: Maybe<TrainingWhereInput[] | TrainingWhereInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export type UserWhereUniqueInput = AtLeastOne<{
 | 
	
		
			
				|  |  | +  id: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  email?: Maybe<String>;
 | 
	
		
			
				|  |  | +}>;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockCreateInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  sequence: Int;
 | 
	
		
			
				|  |  | +  title: String;
 | 
	
		
			
				|  |  | +  duration: Int;
 | 
	
		
			
				|  |  | +  variation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  format?: Maybe<FormatCreateOneInput>;
 | 
	
		
			
				|  |  | +  tracks?: Maybe<TrackCreateManyInput>;
 | 
	
		
			
				|  |  | +  excersises?: Maybe<ExcersiseCreateManyInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseCreateManyInput {
 | 
	
		
			
				|  |  | +  create?: Maybe<ExcersiseCreateInput[] | ExcersiseCreateInput>;
 | 
	
		
			
				|  |  | +  connect?: Maybe<ExcersiseWhereUniqueInput[] | ExcersiseWhereUniqueInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseCreateInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  name: String;
 | 
	
		
			
				|  |  | +  description: String;
 | 
	
		
			
				|  |  | +  video: String;
 | 
	
		
			
				|  |  | +  targets?: Maybe<ExcersiseCreatetargetsInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseCreatetargetsInput {
 | 
	
		
			
				|  |  | +  set?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockUpdateInput {
 | 
	
		
			
				|  |  | +  sequence?: Maybe<Int>;
 | 
	
		
			
				|  |  | +  title?: Maybe<String>;
 | 
	
		
			
				|  |  | +  duration?: Maybe<Int>;
 | 
	
		
			
				|  |  | +  variation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  format?: Maybe<FormatUpdateOneInput>;
 | 
	
		
			
				|  |  | +  tracks?: Maybe<TrackUpdateManyInput>;
 | 
	
		
			
				|  |  | +  excersises?: Maybe<ExcersiseUpdateManyInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseUpdateManyInput {
 | 
	
		
			
				|  |  | +  create?: Maybe<ExcersiseCreateInput[] | ExcersiseCreateInput>;
 | 
	
		
			
				|  |  | +  update?: Maybe<
 | 
	
		
			
				|  |  | +    | ExcersiseUpdateWithWhereUniqueNestedInput[]
 | 
	
		
			
				|  |  | +    | ExcersiseUpdateWithWhereUniqueNestedInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +  upsert?: Maybe<
 | 
	
		
			
				|  |  | +    | ExcersiseUpsertWithWhereUniqueNestedInput[]
 | 
	
		
			
				|  |  | +    | ExcersiseUpsertWithWhereUniqueNestedInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +  delete?: Maybe<ExcersiseWhereUniqueInput[] | ExcersiseWhereUniqueInput>;
 | 
	
		
			
				|  |  | +  connect?: Maybe<ExcersiseWhereUniqueInput[] | ExcersiseWhereUniqueInput>;
 | 
	
		
			
				|  |  | +  set?: Maybe<ExcersiseWhereUniqueInput[] | ExcersiseWhereUniqueInput>;
 | 
	
		
			
				|  |  | +  disconnect?: Maybe<ExcersiseWhereUniqueInput[] | ExcersiseWhereUniqueInput>;
 | 
	
		
			
				|  |  | +  deleteMany?: Maybe<ExcersiseScalarWhereInput[] | ExcersiseScalarWhereInput>;
 | 
	
		
			
				|  |  | +  updateMany?: Maybe<
 | 
	
		
			
				|  |  | +    | ExcersiseUpdateManyWithWhereNestedInput[]
 | 
	
		
			
				|  |  | +    | ExcersiseUpdateManyWithWhereNestedInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateWithWhereUniqueNestedInput {
 | 
	
		
			
				|  |  | +  where: ExcersiseWhereUniqueInput;
 | 
	
		
			
				|  |  | +  data: ExcersiseUpdateDataInput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateDataInput {
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  description?: Maybe<String>;
 | 
	
		
			
				|  |  | +  video?: Maybe<String>;
 | 
	
		
			
				|  |  | +  targets?: Maybe<ExcersiseUpdatetargetsInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdatetargetsInput {
 | 
	
		
			
				|  |  | +  set?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpsertWithWhereUniqueNestedInput {
 | 
	
		
			
				|  |  | +  where: ExcersiseWhereUniqueInput;
 | 
	
		
			
				|  |  | +  update: ExcersiseUpdateDataInput;
 | 
	
		
			
				|  |  | +  create: ExcersiseCreateInput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseScalarWhereInput {
 | 
	
		
			
				|  |  | +  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<ExcersiseScalarWhereInput[] | ExcersiseScalarWhereInput>;
 | 
	
		
			
				|  |  | +  OR?: Maybe<ExcersiseScalarWhereInput[] | ExcersiseScalarWhereInput>;
 | 
	
		
			
				|  |  | +  NOT?: Maybe<ExcersiseScalarWhereInput[] | ExcersiseScalarWhereInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateManyWithWhereNestedInput {
 | 
	
		
			
				|  |  | +  where: ExcersiseScalarWhereInput;
 | 
	
		
			
				|  |  | +  data: ExcersiseUpdateManyDataInput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateManyDataInput {
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  description?: Maybe<String>;
 | 
	
		
			
				|  |  | +  video?: Maybe<String>;
 | 
	
		
			
				|  |  | +  targets?: Maybe<ExcersiseUpdatetargetsInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockUpdateManyMutationInput {
 | 
	
		
			
				|  |  | +  sequence?: Maybe<Int>;
 | 
	
		
			
				|  |  | +  title?: Maybe<String>;
 | 
	
		
			
				|  |  | +  duration?: Maybe<Int>;
 | 
	
		
			
				|  |  | +  variation?: Maybe<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface CommentCreateInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  text: String;
 | 
	
		
			
				|  |  | +  author: UserCreateOneWithoutCommentsInput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserCreateOneWithoutCommentsInput {
 | 
	
		
			
				|  |  | +  create?: Maybe<UserCreateWithoutCommentsInput>;
 | 
	
		
			
				|  |  | +  connect?: Maybe<UserWhereUniqueInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserCreateWithoutCommentsInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  email: String;
 | 
	
		
			
				|  |  | +  name: String;
 | 
	
		
			
				|  |  | +  abbreviation: String;
 | 
	
		
			
				|  |  | +  password: String;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingCreateManyWithoutUserInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface RatingCreateManyWithoutUserInput {
 | 
	
		
			
				|  |  | +  create?: Maybe<RatingCreateWithoutUserInput[] | RatingCreateWithoutUserInput>;
 | 
	
		
			
				|  |  | +  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface RatingCreateWithoutUserInput {
 | 
	
		
			
				|  |  | +  id?: Maybe<ID_Input>;
 | 
	
		
			
				|  |  | +  value: Int;
 | 
	
		
			
				|  |  | +  comment: 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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 UserUpsertWithoutCommentsInput {
 | 
	
		
			
				|  |  | +  update: UserUpdateWithoutCommentsDataInput;
 | 
	
		
			
				|  |  | +  create: UserCreateWithoutCommentsInput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface CommentUpdateManyMutationInput {
 | 
	
		
			
				|  |  | +  text?: Maybe<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateInput {
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  description?: Maybe<String>;
 | 
	
		
			
				|  |  | +  video?: Maybe<String>;
 | 
	
		
			
				|  |  | +  targets?: Maybe<ExcersiseUpdatetargetsInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseUpdateManyMutationInput {
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  description?: Maybe<String>;
 | 
	
		
			
				|  |  | +  video?: Maybe<String>;
 | 
	
		
			
				|  |  | +  targets?: Maybe<ExcersiseUpdatetargetsInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  abbreviation: String;
 | 
	
		
			
				|  |  | +  password: String;
 | 
	
		
			
				|  |  | +  comments?: Maybe<CommentCreateManyWithoutAuthorInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  content?: Maybe<BlockCreateManyInput>;
 | 
	
		
			
				|  |  | +  trainingDate: DateTimeInput;
 | 
	
		
			
				|  |  | +  participants?: Maybe<UserCreateManyInput>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingCreateManyInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  abbreviation: String;
 | 
	
		
			
				|  |  | +  password: String;
 | 
	
		
			
				|  |  | +  comments?: Maybe<CommentCreateManyWithoutAuthorInput>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingCreateManyWithoutUserInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface RatingCreateManyInput {
 | 
	
		
			
				|  |  | +  create?: Maybe<RatingCreateInput[] | RatingCreateInput>;
 | 
	
		
			
				|  |  | +  connect?: Maybe<RatingWhereUniqueInput[] | RatingWhereUniqueInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrainingUpdateInput {
 | 
	
		
			
				|  |  | +  title?: Maybe<String>;
 | 
	
		
			
				|  |  | +  content?: Maybe<BlockUpdateManyInput>;
 | 
	
		
			
				|  |  | +  trainingDate?: Maybe<DateTimeInput>;
 | 
	
		
			
				|  |  | +  participants?: Maybe<UserUpdateManyInput>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingUpdateManyInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  excersises?: Maybe<ExcersiseUpdateManyInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  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>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_in?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_in?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  abbreviation_lt?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_lte?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_gt?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_gte?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_contains?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_contains?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_starts_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_not_starts_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_ends_with?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation_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>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserUpdateInput {
 | 
	
		
			
				|  |  | +  email?: Maybe<String>;
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +  comments?: Maybe<CommentUpdateManyWithoutAuthorInput>;
 | 
	
		
			
				|  |  | +  ratings?: Maybe<RatingUpdateManyWithoutUserInput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserUpdateManyMutationInput {
 | 
	
		
			
				|  |  | +  email?: Maybe<String>;
 | 
	
		
			
				|  |  | +  name?: Maybe<String>;
 | 
	
		
			
				|  |  | +  abbreviation?: Maybe<String>;
 | 
	
		
			
				|  |  | +  password?: Maybe<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseSubscriptionWhereInput {
 | 
	
		
			
				|  |  | +  mutation_in?: Maybe<MutationType[] | MutationType>;
 | 
	
		
			
				|  |  | +  updatedFields_contains?: Maybe<String>;
 | 
	
		
			
				|  |  | +  updatedFields_contains_every?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  updatedFields_contains_some?: Maybe<String[] | String>;
 | 
	
		
			
				|  |  | +  node?: Maybe<ExcersiseWhereInput>;
 | 
	
		
			
				|  |  | +  AND?: Maybe<
 | 
	
		
			
				|  |  | +    ExcersiseSubscriptionWhereInput[] | ExcersiseSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +  OR?: Maybe<
 | 
	
		
			
				|  |  | +    ExcersiseSubscriptionWhereInput[] | ExcersiseSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +  NOT?: Maybe<
 | 
	
		
			
				|  |  | +    ExcersiseSubscriptionWhereInput[] | ExcersiseSubscriptionWhereInput
 | 
	
		
			
				|  |  | +  >;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 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 Block {
 | 
	
		
			
				|  |  | +  id: ID_Output;
 | 
	
		
			
				|  |  | +  sequence: Int;
 | 
	
		
			
				|  |  | +  title: String;
 | 
	
		
			
				|  |  | +  duration: Int;
 | 
	
		
			
				|  |  | +  variation?: 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;
 | 
	
		
			
				|  |  | +  excersises: <T = FragmentableArray<Excersise>>(args?: {
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: ExcersiseOrderByInput;
 | 
	
		
			
				|  |  | +    skip?: Int;
 | 
	
		
			
				|  |  | +    after?: String;
 | 
	
		
			
				|  |  | +    before?: String;
 | 
	
		
			
				|  |  | +    first?: Int;
 | 
	
		
			
				|  |  | +    last?: Int;
 | 
	
		
			
				|  |  | +  }) => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  excersises: <T = Promise<AsyncIterator<ExcersiseSubscription>>>(args?: {
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: ExcersiseOrderByInput;
 | 
	
		
			
				|  |  | +    skip?: Int;
 | 
	
		
			
				|  |  | +    after?: String;
 | 
	
		
			
				|  |  | +    before?: String;
 | 
	
		
			
				|  |  | +    first?: Int;
 | 
	
		
			
				|  |  | +    last?: Int;
 | 
	
		
			
				|  |  | +  }) => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  excersises: <T = FragmentableArray<Excersise>>(args?: {
 | 
	
		
			
				|  |  | +    where?: ExcersiseWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: ExcersiseOrderByInput;
 | 
	
		
			
				|  |  | +    skip?: Int;
 | 
	
		
			
				|  |  | +    after?: String;
 | 
	
		
			
				|  |  | +    before?: String;
 | 
	
		
			
				|  |  | +    first?: Int;
 | 
	
		
			
				|  |  | +    last?: Int;
 | 
	
		
			
				|  |  | +  }) => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface Format {
 | 
	
		
			
				|  |  | +  id: ID_Output;
 | 
	
		
			
				|  |  | +  name: String;
 | 
	
		
			
				|  |  | +  description: String;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface FormatPromise extends Promise<Format>, Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  description: () => Promise<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface FormatSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<Format>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<AsyncIterator<ID_Output>>;
 | 
	
		
			
				|  |  | +  name: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  description: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface FormatNullablePromise
 | 
	
		
			
				|  |  | +  extends Promise<Format | null>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  description: () => Promise<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface Track {
 | 
	
		
			
				|  |  | +  id: ID_Output;
 | 
	
		
			
				|  |  | +  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 Excersise {
 | 
	
		
			
				|  |  | +  id: ID_Output;
 | 
	
		
			
				|  |  | +  name: String;
 | 
	
		
			
				|  |  | +  description: String;
 | 
	
		
			
				|  |  | +  video: String;
 | 
	
		
			
				|  |  | +  targets: String[];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersisePromise extends Promise<Excersise>, Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  description: () => Promise<String>;
 | 
	
		
			
				|  |  | +  video: () => Promise<String>;
 | 
	
		
			
				|  |  | +  targets: () => Promise<String[]>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<Excersise>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<AsyncIterator<ID_Output>>;
 | 
	
		
			
				|  |  | +  name: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  description: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  video: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  targets: () => Promise<AsyncIterator<String[]>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseNullablePromise
 | 
	
		
			
				|  |  | +  extends Promise<Excersise | null>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  description: () => Promise<String>;
 | 
	
		
			
				|  |  | +  video: () => Promise<String>;
 | 
	
		
			
				|  |  | +  targets: () => 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 PageInfo {
 | 
	
		
			
				|  |  | +  hasNextPage: Boolean;
 | 
	
		
			
				|  |  | +  hasPreviousPage: Boolean;
 | 
	
		
			
				|  |  | +  startCursor?: String;
 | 
	
		
			
				|  |  | +  endCursor?: String;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface PageInfoPromise extends Promise<PageInfo>, Fragmentable {
 | 
	
		
			
				|  |  | +  hasNextPage: () => Promise<Boolean>;
 | 
	
		
			
				|  |  | +  hasPreviousPage: () => Promise<Boolean>;
 | 
	
		
			
				|  |  | +  startCursor: () => Promise<String>;
 | 
	
		
			
				|  |  | +  endCursor: () => Promise<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface PageInfoSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<PageInfo>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  hasNextPage: () => Promise<AsyncIterator<Boolean>>;
 | 
	
		
			
				|  |  | +  hasPreviousPage: () => Promise<AsyncIterator<Boolean>>;
 | 
	
		
			
				|  |  | +  startCursor: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  endCursor: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockEdge {
 | 
	
		
			
				|  |  | +  node: Block;
 | 
	
		
			
				|  |  | +  cursor: String;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockEdgePromise extends Promise<BlockEdge>, Fragmentable {
 | 
	
		
			
				|  |  | +  node: <T = BlockPromise>() => T;
 | 
	
		
			
				|  |  | +  cursor: () => Promise<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockEdgeSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<BlockEdge>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  node: <T = BlockSubscription>() => T;
 | 
	
		
			
				|  |  | +  cursor: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateBlock {
 | 
	
		
			
				|  |  | +  count: Int;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateBlockPromise
 | 
	
		
			
				|  |  | +  extends Promise<AggregateBlock>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  count: () => Promise<Int>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateBlockSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<AggregateBlock>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  count: () => Promise<AsyncIterator<Int>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface 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;
 | 
	
		
			
				|  |  | +  abbreviation: String;
 | 
	
		
			
				|  |  | +  password: String;
 | 
	
		
			
				|  |  | +  createdAt: DateTimeOutput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserPromise extends Promise<User>, Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  email: () => Promise<String>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  abbreviation: () => 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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<User>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<AsyncIterator<ID_Output>>;
 | 
	
		
			
				|  |  | +  email: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  name: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  abbreviation: () => 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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserNullablePromise
 | 
	
		
			
				|  |  | +  extends Promise<User | null>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  email: () => Promise<String>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  abbreviation: () => 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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseConnection {
 | 
	
		
			
				|  |  | +  pageInfo: PageInfo;
 | 
	
		
			
				|  |  | +  edges: ExcersiseEdge[];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseConnectionPromise
 | 
	
		
			
				|  |  | +  extends Promise<ExcersiseConnection>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  pageInfo: <T = PageInfoPromise>() => T;
 | 
	
		
			
				|  |  | +  edges: <T = FragmentableArray<ExcersiseEdge>>() => T;
 | 
	
		
			
				|  |  | +  aggregate: <T = AggregateExcersisePromise>() => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseConnectionSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<ExcersiseConnection>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  pageInfo: <T = PageInfoSubscription>() => T;
 | 
	
		
			
				|  |  | +  edges: <T = Promise<AsyncIterator<ExcersiseEdgeSubscription>>>() => T;
 | 
	
		
			
				|  |  | +  aggregate: <T = AggregateExcersiseSubscription>() => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseEdge {
 | 
	
		
			
				|  |  | +  node: Excersise;
 | 
	
		
			
				|  |  | +  cursor: String;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseEdgePromise
 | 
	
		
			
				|  |  | +  extends Promise<ExcersiseEdge>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  node: <T = ExcersisePromise>() => T;
 | 
	
		
			
				|  |  | +  cursor: () => Promise<String>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseEdgeSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<ExcersiseEdge>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  node: <T = ExcersiseSubscription>() => T;
 | 
	
		
			
				|  |  | +  cursor: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateExcersise {
 | 
	
		
			
				|  |  | +  count: Int;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateExcersisePromise
 | 
	
		
			
				|  |  | +  extends Promise<AggregateExcersise>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  count: () => Promise<Int>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface AggregateExcersiseSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<AggregateExcersise>>,
 | 
	
		
			
				|  |  | +    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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrainingPromise extends Promise<Training>, Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  title: () => Promise<String>;
 | 
	
		
			
				|  |  | +  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>;
 | 
	
		
			
				|  |  | +  participants: <T = FragmentableArray<User>>(args?: {
 | 
	
		
			
				|  |  | +    where?: UserWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: UserOrderByInput;
 | 
	
		
			
				|  |  | +    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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrainingSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<Training>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<AsyncIterator<ID_Output>>;
 | 
	
		
			
				|  |  | +  title: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  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>>;
 | 
	
		
			
				|  |  | +  participants: <T = Promise<AsyncIterator<UserSubscription>>>(args?: {
 | 
	
		
			
				|  |  | +    where?: UserWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: UserOrderByInput;
 | 
	
		
			
				|  |  | +    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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrainingNullablePromise
 | 
	
		
			
				|  |  | +  extends Promise<Training | null>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  title: () => Promise<String>;
 | 
	
		
			
				|  |  | +  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>;
 | 
	
		
			
				|  |  | +  participants: <T = FragmentableArray<User>>(args?: {
 | 
	
		
			
				|  |  | +    where?: UserWhereInput;
 | 
	
		
			
				|  |  | +    orderBy?: UserOrderByInput;
 | 
	
		
			
				|  |  | +    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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 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 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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface BlockPreviousValuesPromise
 | 
	
		
			
				|  |  | +  extends Promise<BlockPreviousValues>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  sequence: () => Promise<Int>;
 | 
	
		
			
				|  |  | +  title: () => Promise<String>;
 | 
	
		
			
				|  |  | +  duration: () => Promise<Int>;
 | 
	
		
			
				|  |  | +  variation: () => 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>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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 ExcersiseSubscriptionPayload {
 | 
	
		
			
				|  |  | +  mutation: MutationType;
 | 
	
		
			
				|  |  | +  node: Excersise;
 | 
	
		
			
				|  |  | +  updatedFields: String[];
 | 
	
		
			
				|  |  | +  previousValues: ExcersisePreviousValues;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseSubscriptionPayloadPromise
 | 
	
		
			
				|  |  | +  extends Promise<ExcersiseSubscriptionPayload>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  mutation: () => Promise<MutationType>;
 | 
	
		
			
				|  |  | +  node: <T = ExcersisePromise>() => T;
 | 
	
		
			
				|  |  | +  updatedFields: () => Promise<String[]>;
 | 
	
		
			
				|  |  | +  previousValues: <T = ExcersisePreviousValuesPromise>() => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersiseSubscriptionPayloadSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<ExcersiseSubscriptionPayload>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  mutation: () => Promise<AsyncIterator<MutationType>>;
 | 
	
		
			
				|  |  | +  node: <T = ExcersiseSubscription>() => T;
 | 
	
		
			
				|  |  | +  updatedFields: () => Promise<AsyncIterator<String[]>>;
 | 
	
		
			
				|  |  | +  previousValues: <T = ExcersisePreviousValuesSubscription>() => T;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersisePreviousValues {
 | 
	
		
			
				|  |  | +  id: ID_Output;
 | 
	
		
			
				|  |  | +  name: String;
 | 
	
		
			
				|  |  | +  description: String;
 | 
	
		
			
				|  |  | +  video: String;
 | 
	
		
			
				|  |  | +  targets: String[];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersisePreviousValuesPromise
 | 
	
		
			
				|  |  | +  extends Promise<ExcersisePreviousValues>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  description: () => Promise<String>;
 | 
	
		
			
				|  |  | +  video: () => Promise<String>;
 | 
	
		
			
				|  |  | +  targets: () => Promise<String[]>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface ExcersisePreviousValuesSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<ExcersisePreviousValues>>,
 | 
	
		
			
				|  |  | +    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;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface TrainingPreviousValuesPromise
 | 
	
		
			
				|  |  | +  extends Promise<TrainingPreviousValues>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  title: () => Promise<String>;
 | 
	
		
			
				|  |  | +  createdAt: () => Promise<DateTimeOutput>;
 | 
	
		
			
				|  |  | +  trainingDate: () => Promise<DateTimeOutput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +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;
 | 
	
		
			
				|  |  | +  abbreviation: String;
 | 
	
		
			
				|  |  | +  password: String;
 | 
	
		
			
				|  |  | +  createdAt: DateTimeOutput;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserPreviousValuesPromise
 | 
	
		
			
				|  |  | +  extends Promise<UserPreviousValues>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<ID_Output>;
 | 
	
		
			
				|  |  | +  email: () => Promise<String>;
 | 
	
		
			
				|  |  | +  name: () => Promise<String>;
 | 
	
		
			
				|  |  | +  abbreviation: () => Promise<String>;
 | 
	
		
			
				|  |  | +  password: () => Promise<String>;
 | 
	
		
			
				|  |  | +  createdAt: () => Promise<DateTimeOutput>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export interface UserPreviousValuesSubscription
 | 
	
		
			
				|  |  | +  extends Promise<AsyncIterator<UserPreviousValues>>,
 | 
	
		
			
				|  |  | +    Fragmentable {
 | 
	
		
			
				|  |  | +  id: () => Promise<AsyncIterator<ID_Output>>;
 | 
	
		
			
				|  |  | +  email: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  name: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  abbreviation: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  password: () => Promise<AsyncIterator<String>>;
 | 
	
		
			
				|  |  | +  createdAt: () => Promise<AsyncIterator<DateTimeOutput>>;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/*
 | 
	
		
			
				|  |  | +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 `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 `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 `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: "Training",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Block",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Format",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Track",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Excersise",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Rating",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  },
 | 
	
		
			
				|  |  | +  {
 | 
	
		
			
				|  |  | +    name: "Comment",
 | 
	
		
			
				|  |  | +    embedded: false
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +/**
 | 
	
		
			
				|  |  | + * Type Defs
 | 
	
		
			
				|  |  | + */
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +export const prisma: Prisma;
 |