/* eslint-disable */
import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string };
  String: { input: string; output: string };
  Boolean: { input: boolean; output: boolean };
  Int: { input: number; output: number };
  Float: { input: number; output: number };
  /**
   * The `Date` scalar type represents a Date
   * value as specified by
   * [iso8601](https://en.wikipedia.org/wiki/ISO_8601).
   */
  Date: { input: any; output: any };
  /**
   * The `DateTime` scalar type represents a DateTime
   * value as specified by
   * [iso8601](https://en.wikipedia.org/wiki/ISO_8601).
   */
  DateTime: { input: any; output: any };
  GenericStreamFieldType: { input: any; output: any };
  /**
   * Allows use of a JSON String for input / output from the GraphQL schema.
   *
   * Use of this type is *not recommended* as you lose the benefits of having a defined, static
   * schema (one of the key benefits of GraphQL).
   */
  JSONString: { input: any; output: any };
  /**
   * Leverages the internal Python implementation of UUID (uuid.UUID) to provide native UUID objects
   * in fields, resolvers and input.
   */
  UUID: { input: any; output: any };
};

export type AddCommentInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  comment: Scalars['String']['input'];
  roomEntry: Scalars['ID']['input'];
};

export type AddCommentPayload = {
  __typename?: 'AddCommentPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  comment?: Maybe<CommentNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type AddContentBlockInput = {
  after?: InputMaybe<Scalars['ID']['input']>;
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  contentBlock?: InputMaybe<ContentBlockInput>;
  parent?: InputMaybe<Scalars['ID']['input']>;
};

export type AddContentBlockPayload = {
  __typename?: 'AddContentBlockPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  newContentBlock?: Maybe<ContentBlockNode>;
};

export type AddModuleRoomEntryArgument = {
  contents?: InputMaybe<Array<InputMaybe<ContentElementInput>>>;
  roomSlug: Scalars['String']['input'];
  schoolClass: Scalars['String']['input'];
  title: Scalars['String']['input'];
};

export type AddModuleRoomEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  roomEntry?: InputMaybe<AddModuleRoomEntryArgument>;
};

export type AddModuleRoomEntryPayload = {
  __typename?: 'AddModuleRoomEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  roomEntry?: Maybe<RoomEntryNode>;
};

export type AddNoteArgument = {
  block?: InputMaybe<Scalars['String']['input']>;
  content?: InputMaybe<Scalars['UUID']['input']>;
  parent?: InputMaybe<Scalars['ID']['input']>;
  text: Scalars['String']['input'];
  type?: InputMaybe<Scalars['String']['input']>;
};

export type AddNoteInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  note?: InputMaybe<AddNoteArgument>;
};

export type AddNotePayload = {
  __typename?: 'AddNotePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  note?: Maybe<NoteNode>;
};

export type AddObjectiveArgument = {
  objectiveGroup?: InputMaybe<Scalars['ID']['input']>;
  text: Scalars['String']['input'];
};

export type AddObjectiveInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  objective?: InputMaybe<AddObjectiveArgument>;
};

export type AddObjectivePayload = {
  __typename?: 'AddObjectivePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  objective?: Maybe<ObjectiveNode>;
};

export type AddProjectArgument = {
  appearance?: InputMaybe<Scalars['String']['input']>;
  description?: InputMaybe<Scalars['String']['input']>;
  objectives?: InputMaybe<Scalars['String']['input']>;
  title?: InputMaybe<Scalars['String']['input']>;
};

export type AddProjectEntryArgument = {
  description?: InputMaybe<Scalars['String']['input']>;
  documentUrl?: InputMaybe<Scalars['String']['input']>;
  project: Scalars['String']['input'];
};

export type AddProjectEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  projectEntry?: InputMaybe<AddProjectEntryArgument>;
};

export type AddProjectEntryPayload = {
  __typename?: 'AddProjectEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  projectEntry?: Maybe<ProjectEntryNode>;
};

export type AddProjectInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  project?: InputMaybe<AddProjectArgument>;
};

export type AddProjectPayload = {
  __typename?: 'AddProjectPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  project?: Maybe<ProjectNode>;
};

export type AddRemoveMemberInput = {
  active: Scalars['Boolean']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  member: Scalars['ID']['input'];
  schoolClass: Scalars['ID']['input'];
};

export type AddRemoveMemberPayload = {
  __typename?: 'AddRemoveMemberPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type AddRoomArgument = {
  appearance?: InputMaybe<Scalars['String']['input']>;
  description?: InputMaybe<Scalars['String']['input']>;
  schoolClass?: InputMaybe<SchoolClassInput>;
  title?: InputMaybe<Scalars['String']['input']>;
};

export type AddRoomEntryArgument = {
  contents?: InputMaybe<Array<InputMaybe<ContentElementInput>>>;
  roomSlug: Scalars['String']['input'];
  title: Scalars['String']['input'];
};

export type AddRoomEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  roomEntry?: InputMaybe<AddRoomEntryArgument>;
};

export type AddRoomEntryPayload = {
  __typename?: 'AddRoomEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  roomEntry?: Maybe<RoomEntryNode>;
};

export type AddRoomInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  room?: InputMaybe<AddRoomArgument>;
};

export type AddRoomPayload = {
  __typename?: 'AddRoomPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  room?: Maybe<RoomNode>;
};

export type AnswerNode = Node & {
  __typename?: 'AnswerNode';
  data: Scalars['JSONString']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  owner: PrivateUserNode;
  pk?: Maybe<Scalars['Int']['output']>;
  survey: SurveyNode;
};

export type AnswerNodeConnection = {
  __typename?: 'AnswerNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<AnswerNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `AnswerNode` and its cursor. */
export type AnswerNodeEdge = {
  __typename?: 'AnswerNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<AnswerNode>;
};

export type ApplySnapshotInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  selectedClass: Scalars['ID']['input'];
  snapshot: Scalars['ID']['input'];
};

export type ApplySnapshotPayload = {
  __typename?: 'ApplySnapshotPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  module?: Maybe<ModuleNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type AssignmentInput = {
  answer: Scalars['String']['input'];
  document?: InputMaybe<Scalars['String']['input']>;
  final?: InputMaybe<Scalars['Boolean']['input']>;
  id: Scalars['ID']['input'];
};

export type AssignmentNode = Node & {
  __typename?: 'AssignmentNode';
  assignment: Scalars['String']['output'];
  created: Scalars['DateTime']['output'];
  deleted: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  modified: Scalars['DateTime']['output'];
  module: ModuleNode;
  owner?: Maybe<PrivateUserNode>;
  solution?: Maybe<Scalars['String']['output']>;
  submission?: Maybe<StudentSubmissionNode>;
  submissions?: Maybe<Array<Maybe<StudentSubmissionNode>>>;
  taskbaseId?: Maybe<Scalars['String']['output']>;
  title: Scalars['String']['output'];
  userCreated: Scalars['Boolean']['output'];
};

/** An enumeration. */
export enum BooksModuleCategoryFilterAttributeTypeChoices {
  /** All */
  All = 'ALL',
  /** Exact */
  Exact = 'EXACT',
}

/** An enumeration. */
export enum BooksModuleLevelFilterAttributeTypeChoices {
  /** All */
  All = 'ALL',
  /** Exact */
  Exact = 'EXACT',
}

export type ChapterBookmarkNode = Node & {
  __typename?: 'ChapterBookmarkNode';
  chapter: ChapterNode;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  note?: Maybe<NoteNode>;
  user: PrivateUserNode;
};

export type ChapterBookmarkNodeConnection = {
  __typename?: 'ChapterBookmarkNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ChapterBookmarkNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ChapterBookmarkNode` and its cursor. */
export type ChapterBookmarkNodeEdge = {
  __typename?: 'ChapterBookmarkNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ChapterBookmarkNode>;
};

export type ChapterInterface = {
  description?: Maybe<Scalars['String']['output']>;
  title?: Maybe<Scalars['String']['output']>;
};

export type ChapterNode = ChapterInterface &
  Node & {
    __typename?: 'ChapterNode';
    bookmark?: Maybe<ChapterBookmarkNode>;
    contentBlocks?: Maybe<Array<Maybe<ContentBlockNode>>>;
    description?: Maybe<Scalars['String']['output']>;
    descriptionHiddenFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
    /** The ID of the object */
    id: Scalars['ID']['output'];
    path?: Maybe<Scalars['String']['output']>;
    /** Der Name der Seite, wie er in URLs angezeigt werden soll, z.B. http://domain.com/blog/[my-slug]/ */
    slug: Scalars['String']['output'];
    title?: Maybe<Scalars['String']['output']>;
    titleHiddenFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
  };

export type ChapterNodeConnection = {
  __typename?: 'ChapterNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ChapterNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ChapterNode` and its cursor. */
export type ChapterNodeEdge = {
  __typename?: 'ChapterNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ChapterNode>;
};

/**
 * We need to build this ourselves, because we want the active property on the node, because providing it on the
 * Connection or Edge for a UserNodeConnection is difficult.
 */
export type ClassMemberNode = {
  __typename?: 'ClassMemberNode';
  active?: Maybe<Scalars['Boolean']['output']>;
  firstName?: Maybe<Scalars['String']['output']>;
  id?: Maybe<Scalars['ID']['output']>;
  isMe?: Maybe<Scalars['Boolean']['output']>;
  isTeacher?: Maybe<Scalars['Boolean']['output']>;
  lastName?: Maybe<Scalars['String']['output']>;
  user?: Maybe<PublicUserNode>;
};

export type CommentNode = Node & {
  __typename?: 'CommentNode';
  created: Scalars['DateTime']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  owner?: Maybe<PublicUserNode>;
  text: Scalars['String']['output'];
};

export type ContentBlockBookmarkNode = Node & {
  __typename?: 'ContentBlockBookmarkNode';
  contentBlock: ContentBlockNode;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  note?: Maybe<NoteNode>;
  user: PrivateUserNode;
  uuid?: Maybe<Scalars['UUID']['output']>;
};

export type ContentBlockBookmarkNodeConnection = {
  __typename?: 'ContentBlockBookmarkNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ContentBlockBookmarkNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ContentBlockBookmarkNode` and its cursor. */
export type ContentBlockBookmarkNodeEdge = {
  __typename?: 'ContentBlockBookmarkNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ContentBlockBookmarkNode>;
};

export type ContentBlockInput = {
  contents?: InputMaybe<Array<InputMaybe<ContentElementInput>>>;
  title?: InputMaybe<Scalars['String']['input']>;
  type?: InputMaybe<Scalars['String']['input']>;
  visibility?: InputMaybe<Array<InputMaybe<UserGroupBlockVisibility>>>;
};

export type ContentBlockInterface = {
  contents?: Maybe<Scalars['GenericStreamFieldType']['output']>;
  title?: Maybe<Scalars['String']['output']>;
  type: Scalars['String']['output'];
};

export type ContentBlockNode = ContentBlockInterface &
  Node & {
    __typename?: 'ContentBlockNode';
    bookmarks?: Maybe<Array<Maybe<ContentBlockBookmarkNode>>>;
    contents?: Maybe<Scalars['GenericStreamFieldType']['output']>;
    hiddenFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
    /** The ID of the object */
    id: Scalars['ID']['output'];
    instrumentCategory?: Maybe<InstrumentCategoryNode>;
    mine?: Maybe<Scalars['Boolean']['output']>;
    originalCreator?: Maybe<PublicUserNode>;
    path?: Maybe<Scalars['String']['output']>;
    /** Der Name der Seite, wie er in URLs angezeigt werden soll, z.B. http://domain.com/blog/[my-slug]/ */
    slug: Scalars['String']['output'];
    title?: Maybe<Scalars['String']['output']>;
    type: Scalars['String']['output'];
    userCreated: Scalars['Boolean']['output'];
    visibleFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
  };

export type ContentBlockNodeConnection = {
  __typename?: 'ContentBlockNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ContentBlockNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ContentBlockNode` and its cursor. */
export type ContentBlockNodeEdge = {
  __typename?: 'ContentBlockNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ContentBlockNode>;
};

export type ContentElementInput = {
  contents?: InputMaybe<Array<InputMaybe<ContentElementInput>>>;
  id?: InputMaybe<Scalars['String']['input']>;
  type: InputTypes;
  value?: InputMaybe<ContentElementValueInput>;
};

export type ContentElementValueInput = {
  /** To be used for assignment type */
  assignment?: InputMaybe<Scalars['String']['input']>;
  /** To be used for basic_knowledge type */
  description?: InputMaybe<Scalars['String']['input']>;
  /** To be used for assignment type */
  id?: InputMaybe<Scalars['String']['input']>;
  /** To be used for link_block, text_block types */
  text?: InputMaybe<Scalars['String']['input']>;
  /** To be used for image_block, assignment type */
  title?: InputMaybe<Scalars['String']['input']>;
  /** To be used for link, image_block types */
  url?: InputMaybe<Scalars['String']['input']>;
};

export type CouponInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  couponCode?: InputMaybe<Scalars['String']['input']>;
};

export type CouponPayload = {
  __typename?: 'CouponPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  result?: Maybe<RedeemCouponResult>;
};

export type CreateSchoolClassInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  name?: InputMaybe<Scalars['String']['input']>;
};

export type CreateSchoolClassPayload = {
  __typename?: 'CreateSchoolClassPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  result?: Maybe<CreateSchoolClassResult>;
};

export type CreateSchoolClassResult = DuplicateName | SchoolClassNode;

export type CreateSnapshotInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  module: Scalars['String']['input'];
  selectedClass: Scalars['ID']['input'];
};

export type CreateSnapshotPayload = {
  __typename?: 'CreateSnapshotPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  snapshot?: Maybe<SnapshotNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type CreateTeamInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  name: Scalars['String']['input'];
};

export type CreateTeamPayload = {
  __typename?: 'CreateTeamPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  result?: Maybe<CreateTeamResult>;
};

export type CreateTeamResult = DuplicateName | TeamNode;

export type DeleteContentBlockInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DeleteContentBlockPayload = {
  __typename?: 'DeleteContentBlockPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteObjectiveInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DeleteObjectivePayload = {
  __typename?: 'DeleteObjectivePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteProjectEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DeleteProjectEntryPayload = {
  __typename?: 'DeleteProjectEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteProjectInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  slug: Scalars['String']['input'];
};

export type DeleteProjectPayload = {
  __typename?: 'DeleteProjectPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteRoomEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  slug: Scalars['String']['input'];
};

export type DeleteRoomEntryPayload = {
  __typename?: 'DeleteRoomEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  roomId?: Maybe<Scalars['ID']['output']>;
  roomSlug?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteRoomInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DeleteRoomPayload = {
  __typename?: 'DeleteRoomPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type DeleteSnapshotInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DeleteSnapshotPayload = {
  __typename?: 'DeleteSnapshotPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  result?: Maybe<DeleteSnapshotResult>;
};

export type DeleteSnapshotResult = NotOwner | Success;

/** Debugging information for the current query. */
export type DjangoDebug = {
  __typename?: 'DjangoDebug';
  /** Raise exceptions for this API query. */
  exceptions?: Maybe<Array<Maybe<DjangoDebugException>>>;
  /** Executed SQL queries for this API query. */
  sql?: Maybe<Array<Maybe<DjangoDebugSql>>>;
};

/** Represents a single exception raised. */
export type DjangoDebugException = {
  __typename?: 'DjangoDebugException';
  /** The class of the exception */
  excType: Scalars['String']['output'];
  /** The message of the exception */
  message: Scalars['String']['output'];
  /** The stack trace */
  stack: Scalars['String']['output'];
};

/** Represents a single database query made to a Django managed DB. */
export type DjangoDebugSql = {
  __typename?: 'DjangoDebugSQL';
  /** The Django database alias (e.g. 'default'). */
  alias: Scalars['String']['output'];
  /** Duration of this database query in seconds. */
  duration: Scalars['Float']['output'];
  /** Postgres connection encoding if available. */
  encoding?: Maybe<Scalars['String']['output']>;
  /** Whether this database query was a SELECT. */
  isSelect: Scalars['Boolean']['output'];
  /** Whether this database query took more than 10 seconds. */
  isSlow: Scalars['Boolean']['output'];
  /** Postgres isolation level if available. */
  isoLevel?: Maybe<Scalars['String']['output']>;
  /** JSON encoded database query parameters. */
  params: Scalars['String']['output'];
  /** The raw SQL of this query, without params. */
  rawSql: Scalars['String']['output'];
  /** The actual SQL sent to this database. */
  sql?: Maybe<Scalars['String']['output']>;
  /** Start time of this database query. */
  startTime: Scalars['Float']['output'];
  /** Stop time of this database query. */
  stopTime: Scalars['Float']['output'];
  /** Postgres transaction ID if available. */
  transId?: Maybe<Scalars['String']['output']>;
  /** Postgres transaction status if available. */
  transStatus?: Maybe<Scalars['String']['output']>;
  /** The type of database being used (e.g. postrgesql, mysql, sqlite). */
  vendor: Scalars['String']['output'];
};

export type DuplicateContentBlockInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type DuplicateContentBlockPayload = {
  __typename?: 'DuplicateContentBlockPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  contentBlock?: Maybe<ContentBlockNode>;
};

export type DuplicateName = FailureNode & {
  __typename?: 'DuplicateName';
  reason?: Maybe<Scalars['String']['output']>;
};

export type FailureNode = {
  reason?: Maybe<Scalars['String']['output']>;
};

export type FieldError = {
  __typename?: 'FieldError';
  code?: Maybe<Scalars['String']['output']>;
};

export enum InputTypes {
  Assignment = 'assignment',
  ContentListItem = 'content_list_item',
  DocumentBlock = 'document_block',
  ImageBlock = 'image_block',
  ImageUrlBlock = 'image_url_block',
  LinkBlock = 'link_block',
  Readonly = 'readonly',
  Subtitle = 'subtitle',
  TextBlock = 'text_block',
  VideoBlock = 'video_block',
}

export type InstrumentBookmarkNode = Node & {
  __typename?: 'InstrumentBookmarkNode';
  /** The ID of the object */
  id: Scalars['ID']['output'];
  instrument: InstrumentNode;
  note?: Maybe<NoteNode>;
  user: PrivateUserNode;
  uuid?: Maybe<Scalars['UUID']['output']>;
};

export type InstrumentCategoryNode = Node & {
  __typename?: 'InstrumentCategoryNode';
  background: Scalars['String']['output'];
  foreground: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  types?: Maybe<Array<Maybe<InstrumentTypeNode>>>;
};

export type InstrumentNode = Node & {
  __typename?: 'InstrumentNode';
  bookmarks?: Maybe<Array<Maybe<InstrumentBookmarkNode>>>;
  contents?: Maybe<Scalars['GenericStreamFieldType']['output']>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  intro: Scalars['String']['output'];
  language?: Maybe<Scalars['String']['output']>;
  /** Der Name der Seite, wie er in URLs angezeigt werden soll, z.B. http://domain.com/blog/[my-slug]/ */
  slug: Scalars['String']['output'];
  /** Der Seitentitel, der öffentlich angezeigt werden soll */
  title: Scalars['String']['output'];
  type?: Maybe<InstrumentTypeNode>;
};

export type InstrumentNodeConnection = {
  __typename?: 'InstrumentNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<InstrumentNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `InstrumentNode` and its cursor. */
export type InstrumentNodeEdge = {
  __typename?: 'InstrumentNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<InstrumentNode>;
};

export type InstrumentTypeNode = Node & {
  __typename?: 'InstrumentTypeNode';
  category?: Maybe<InstrumentCategoryNode>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  type: Scalars['String']['output'];
};

export type InvalidCoupon = FailureNode & {
  __typename?: 'InvalidCoupon';
  reason?: Maybe<Scalars['String']['output']>;
};

export type JoinClassInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  code: Scalars['String']['input'];
};

export type JoinClassPayload = {
  __typename?: 'JoinClassPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  schoolClass?: Maybe<SchoolClassNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type JoinTeamInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  code: Scalars['String']['input'];
};

export type JoinTeamPayload = {
  __typename?: 'JoinTeamPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
  team?: Maybe<TeamNode>;
};

export type LeaveTeam = {
  __typename?: 'LeaveTeam';
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type Logout = {
  __typename?: 'Logout';
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type ModuleBookmarkNode = {
  __typename?: 'ModuleBookmarkNode';
  id: Scalars['ID']['output'];
  module: ModuleNode;
  note?: Maybe<NoteNode>;
  user: PrivateUserNode;
};

export type ModuleCategoryNode = Node & {
  __typename?: 'ModuleCategoryNode';
  filterAttributeType: BooksModuleCategoryFilterAttributeTypeChoices;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  moduleSet: ModuleNodeConnection;
  name: Scalars['String']['output'];
  /** Order in the Dropdown List */
  order: Scalars['Int']['output'];
};

export type ModuleCategoryNodeModuleSetArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  slug_Icontains?: InputMaybe<Scalars['String']['input']>;
  slug_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  title?: InputMaybe<Scalars['String']['input']>;
  title_Icontains?: InputMaybe<Scalars['String']['input']>;
  title_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type ModuleConnection = {
  __typename?: 'ModuleConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ModuleEdge>>;
  nodes?: Maybe<Array<Maybe<ModuleNode>>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `Module` and its cursor. */
export type ModuleEdge = {
  __typename?: 'ModuleEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ModuleNode>;
};

export type ModuleInterface = {
  heroImage: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
  topic?: Maybe<TopicNode>;
};

export type ModuleLevelNode = Node & {
  __typename?: 'ModuleLevelNode';
  filterAttributeType: BooksModuleLevelFilterAttributeTypeChoices;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  moduleSet: ModuleNodeConnection;
  name: Scalars['String']['output'];
  /** Order in the Dropdown List */
  order: Scalars['Int']['output'];
};

export type ModuleLevelNodeModuleSetArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  slug_Icontains?: InputMaybe<Scalars['String']['input']>;
  slug_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  title?: InputMaybe<Scalars['String']['input']>;
  title_Icontains?: InputMaybe<Scalars['String']['input']>;
  title_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type ModuleNode = ModuleInterface & {
  __typename?: 'ModuleNode';
  assignments?: Maybe<Array<Maybe<AssignmentNode>>>;
  bookmark?: Maybe<ModuleBookmarkNode>;
  category?: Maybe<ModuleCategoryNode>;
  chapters?: Maybe<Array<Maybe<ChapterNode>>>;
  heroImage: Scalars['String']['output'];
  /** e.g. 'Reuters', 'Wikipedia' */
  heroSource: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  inEditMode: Scalars['Boolean']['output'];
  intro: Scalars['String']['output'];
  language?: Maybe<Scalars['String']['output']>;
  level?: Maybe<ModuleLevelNode>;
  /** e.g. 'Intro' or 'Modul 1' */
  metaTitle: Scalars['String']['output'];
  myAnswers?: Maybe<AnswerNodeConnection>;
  myChapterBookmarks?: Maybe<ChapterBookmarkNodeConnection>;
  myContentBookmarks?: Maybe<ContentBlockBookmarkNodeConnection>;
  mySubmissions?: Maybe<StudentSubmissionNodeConnection>;
  objectiveGroups?: Maybe<Array<Maybe<ObjectiveGroupNode>>>;
  pk?: Maybe<Scalars['Int']['output']>;
  /** Der Name der Seite, wie er in URLs angezeigt werden soll, z.B. http://domain.com/blog/[my-slug]/ */
  slug: Scalars['String']['output'];
  snapshots?: Maybe<Array<Maybe<SnapshotNode>>>;
  solutionsEnabled?: Maybe<Scalars['Boolean']['output']>;
  teaser: Scalars['String']['output'];
  /** Der Seitentitel, der öffentlich angezeigt werden soll */
  title: Scalars['String']['output'];
  topic?: Maybe<TopicNode>;
};

export type ModuleNodeMyAnswersArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type ModuleNodeMyChapterBookmarksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type ModuleNodeMyContentBookmarksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type ModuleNodeMySubmissionsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type ModuleNodeConnection = {
  __typename?: 'ModuleNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ModuleNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ModuleNode` and its cursor. */
export type ModuleNodeEdge = {
  __typename?: 'ModuleNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ModuleNode>;
};

export type MutateContentBlockInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  contentBlock?: InputMaybe<ContentBlockInput>;
  id: Scalars['ID']['input'];
};

export type MutateContentBlockPayload = {
  __typename?: 'MutateContentBlockPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  contentBlock?: Maybe<ContentBlockNode>;
};

export type Mutation = {
  __typename?: 'Mutation';
  _debug?: Maybe<DjangoDebug>;
  addComment?: Maybe<AddCommentPayload>;
  addContentBlock?: Maybe<AddContentBlockPayload>;
  addModuleRoomEntry?: Maybe<AddModuleRoomEntryPayload>;
  addNote?: Maybe<AddNotePayload>;
  addObjective?: Maybe<AddObjectivePayload>;
  addProject?: Maybe<AddProjectPayload>;
  addProjectEntry?: Maybe<AddProjectEntryPayload>;
  addRemoveMember?: Maybe<AddRemoveMemberPayload>;
  addRoom?: Maybe<AddRoomPayload>;
  addRoomEntry?: Maybe<AddRoomEntryPayload>;
  applySnapshot?: Maybe<ApplySnapshotPayload>;
  coupon?: Maybe<CouponPayload>;
  createSchoolClass?: Maybe<CreateSchoolClassPayload>;
  createSnapshot?: Maybe<CreateSnapshotPayload>;
  createTeam?: Maybe<CreateTeamPayload>;
  deleteContentBlock?: Maybe<DeleteContentBlockPayload>;
  deleteObjective?: Maybe<DeleteObjectivePayload>;
  deleteProject?: Maybe<DeleteProjectPayload>;
  deleteProjectEntry?: Maybe<DeleteProjectEntryPayload>;
  deleteRoom?: Maybe<DeleteRoomPayload>;
  deleteRoomEntry?: Maybe<DeleteRoomEntryPayload>;
  deleteSnapshot?: Maybe<DeleteSnapshotPayload>;
  duplicateContentBlock?: Maybe<DuplicateContentBlockPayload>;
  joinClass?: Maybe<JoinClassPayload>;
  joinTeam?: Maybe<JoinTeamPayload>;
  leaveTeam?: Maybe<LeaveTeam>;
  logout?: Maybe<Logout>;
  mutateContentBlock?: Maybe<MutateContentBlockPayload>;
  setLanguage?: Maybe<PrivateUserNode>;
  shareSnapshot?: Maybe<ShareSnapshotPayload>;
  spellCheck?: Maybe<SpellCheckPayload>;
  syncModuleVisibility?: Maybe<SyncModuleVisibilityPayload>;
  updateAnswer?: Maybe<UpdateAnswerPayload>;
  updateAssignment?: Maybe<UpdateAssignmentPayload>;
  updateAvatar?: Maybe<UpdateAvatarPayload>;
  updateChapterBookmark?: Maybe<UpdateChapterBookmarkPayload>;
  updateChapterVisibility?: Maybe<UpdateChapterVisibilityPayload>;
  updateContentBookmark?: Maybe<UpdateContentBookmarkPayload>;
  updateInstrumentBookmark?: Maybe<UpdateInstrumentBookmarkPayload>;
  updateLastModule?: Maybe<UpdateLastModulePayload>;
  updateLastModuleLevel?: Maybe<UpdateLastModuleLevelPayload>;
  updateLastTopic?: Maybe<UpdateLastTopicPayload>;
  updateModuleBookmark?: Maybe<UpdateModuleBookmarkPayload>;
  updateNote?: Maybe<UpdateNotePayload>;
  updateObjectiveGroupVisibility?: Maybe<UpdateObjectiveGroupVisibilityPayload>;
  updateObjectiveVisibility?: Maybe<UpdateObjectiveVisibilityPayload>;
  updateOnboardingProgress?: Maybe<UpdateOnboardingProgress>;
  updatePassword?: Maybe<UpdatePasswordPayload>;
  updateProject?: Maybe<UpdateProjectPayload>;
  updateProjectEntry?: Maybe<UpdateProjectEntryPayload>;
  updateProjectSharedState?: Maybe<UpdateProjectSharedStatePayload>;
  updateRoom?: Maybe<UpdateRoomPayload>;
  updateRoomEntry?: Maybe<UpdateRoomEntryPayload>;
  updateRoomVisibility?: Maybe<UpdateRoomVisibilityPayload>;
  updateSchoolClass?: Maybe<UpdateSchoolClassPayload>;
  updateSetting?: Maybe<UpdateSettingPayload>;
  updateSnapshot?: Maybe<UpdateSnapshotPayload>;
  updateSolutionVisibility?: Maybe<UpdateSolutionVisibilityPayload>;
  updateSubmissionFeedback?: Maybe<UpdateSubmissionFeedbackPayload>;
  updateTeam?: Maybe<UpdateTeamPayload>;
};

export type MutationAddCommentArgs = {
  input: AddCommentInput;
};

export type MutationAddContentBlockArgs = {
  input: AddContentBlockInput;
};

export type MutationAddModuleRoomEntryArgs = {
  input: AddModuleRoomEntryInput;
};

export type MutationAddNoteArgs = {
  input: AddNoteInput;
};

export type MutationAddObjectiveArgs = {
  input: AddObjectiveInput;
};

export type MutationAddProjectArgs = {
  input: AddProjectInput;
};

export type MutationAddProjectEntryArgs = {
  input: AddProjectEntryInput;
};

export type MutationAddRemoveMemberArgs = {
  input: AddRemoveMemberInput;
};

export type MutationAddRoomArgs = {
  input: AddRoomInput;
};

export type MutationAddRoomEntryArgs = {
  input: AddRoomEntryInput;
};

export type MutationApplySnapshotArgs = {
  input: ApplySnapshotInput;
};

export type MutationCouponArgs = {
  input: CouponInput;
};

export type MutationCreateSchoolClassArgs = {
  input: CreateSchoolClassInput;
};

export type MutationCreateSnapshotArgs = {
  input: CreateSnapshotInput;
};

export type MutationCreateTeamArgs = {
  input: CreateTeamInput;
};

export type MutationDeleteContentBlockArgs = {
  input: DeleteContentBlockInput;
};

export type MutationDeleteObjectiveArgs = {
  input: DeleteObjectiveInput;
};

export type MutationDeleteProjectArgs = {
  input: DeleteProjectInput;
};

export type MutationDeleteProjectEntryArgs = {
  input: DeleteProjectEntryInput;
};

export type MutationDeleteRoomArgs = {
  input: DeleteRoomInput;
};

export type MutationDeleteRoomEntryArgs = {
  input: DeleteRoomEntryInput;
};

export type MutationDeleteSnapshotArgs = {
  input: DeleteSnapshotInput;
};

export type MutationDuplicateContentBlockArgs = {
  input: DuplicateContentBlockInput;
};

export type MutationJoinClassArgs = {
  input: JoinClassInput;
};

export type MutationJoinTeamArgs = {
  input: JoinTeamInput;
};

export type MutationMutateContentBlockArgs = {
  input: MutateContentBlockInput;
};

export type MutationSetLanguageArgs = {
  language: Scalars['String']['input'];
};

export type MutationShareSnapshotArgs = {
  input: ShareSnapshotInput;
};

export type MutationSpellCheckArgs = {
  input: SpellCheckInput;
};

export type MutationSyncModuleVisibilityArgs = {
  input: SyncModuleVisibilityInput;
};

export type MutationUpdateAnswerArgs = {
  input: UpdateAnswerInput;
};

export type MutationUpdateAssignmentArgs = {
  input: UpdateAssignmentInput;
};

export type MutationUpdateAvatarArgs = {
  input: UpdateAvatarInput;
};

export type MutationUpdateChapterBookmarkArgs = {
  input: UpdateChapterBookmarkInput;
};

export type MutationUpdateChapterVisibilityArgs = {
  input: UpdateChapterVisibilityInput;
};

export type MutationUpdateContentBookmarkArgs = {
  input: UpdateContentBookmarkInput;
};

export type MutationUpdateInstrumentBookmarkArgs = {
  input: UpdateInstrumentBookmarkInput;
};

export type MutationUpdateLastModuleArgs = {
  input: UpdateLastModuleInput;
};

export type MutationUpdateLastModuleLevelArgs = {
  input: UpdateLastModuleLevelInput;
};

export type MutationUpdateLastTopicArgs = {
  input: UpdateLastTopicInput;
};

export type MutationUpdateModuleBookmarkArgs = {
  input: UpdateModuleBookmarkInput;
};

export type MutationUpdateNoteArgs = {
  input: UpdateNoteInput;
};

export type MutationUpdateObjectiveGroupVisibilityArgs = {
  input: UpdateObjectiveGroupVisibilityInput;
};

export type MutationUpdateObjectiveVisibilityArgs = {
  input: UpdateObjectiveVisibilityInput;
};

export type MutationUpdatePasswordArgs = {
  input: UpdatePasswordInput;
};

export type MutationUpdateProjectArgs = {
  input: UpdateProjectInput;
};

export type MutationUpdateProjectEntryArgs = {
  input: UpdateProjectEntryInput;
};

export type MutationUpdateProjectSharedStateArgs = {
  input: UpdateProjectSharedStateInput;
};

export type MutationUpdateRoomArgs = {
  input: UpdateRoomInput;
};

export type MutationUpdateRoomEntryArgs = {
  input: UpdateRoomEntryInput;
};

export type MutationUpdateRoomVisibilityArgs = {
  input: UpdateRoomVisibilityInput;
};

export type MutationUpdateSchoolClassArgs = {
  input: UpdateSchoolClassInput;
};

export type MutationUpdateSettingArgs = {
  input: UpdateSettingInput;
};

export type MutationUpdateSnapshotArgs = {
  input: UpdateSnapshotInput;
};

export type MutationUpdateSolutionVisibilityArgs = {
  input: UpdateSolutionVisibilityInput;
};

export type MutationUpdateSubmissionFeedbackArgs = {
  input: UpdateSubmissionFeedbackInput;
};

export type MutationUpdateTeamArgs = {
  input: UpdateTeamInput;
};

export type NewsTeaserNode = Node & {
  __typename?: 'NewsTeaserNode';
  date?: Maybe<Scalars['Date']['output']>;
  description?: Maybe<Scalars['String']['output']>;
  displayDate?: Maybe<Scalars['String']['output']>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  imageSource: Scalars['String']['output'];
  imageUrl?: Maybe<Scalars['String']['output']>;
  newsArticleUrl?: Maybe<Scalars['String']['output']>;
  orderId: Scalars['Int']['output'];
  title: Scalars['String']['output'];
};

/** An object with an ID */
export type Node = {
  /** The ID of the object */
  id: Scalars['ID']['output'];
};

export type NotFound = {
  __typename?: 'NotFound';
  reason?: Maybe<Scalars['String']['output']>;
};

export type NotOwner = FailureNode & {
  __typename?: 'NotOwner';
  reason?: Maybe<Scalars['String']['output']>;
};

export type NoteNode = Node & {
  __typename?: 'NoteNode';
  chapterbookmark?: Maybe<ChapterBookmarkNode>;
  contentblockbookmark?: Maybe<ContentBlockBookmarkNode>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  instrumentbookmark?: Maybe<InstrumentBookmarkNode>;
  modulebookmark?: Maybe<ModuleBookmarkNode>;
  pk?: Maybe<Scalars['Int']['output']>;
  text: Scalars['String']['output'];
};

export type ObjectiveGroupNode = Node & {
  __typename?: 'ObjectiveGroupNode';
  displayTitle?: Maybe<Scalars['String']['output']>;
  hiddenFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  module: ModuleNode;
  objectives?: Maybe<Array<Maybe<ObjectiveNode>>>;
  pk?: Maybe<Scalars['Int']['output']>;
  title?: Maybe<ObjectivesObjectiveGroupTitleChoices>;
};

export type ObjectiveGroupNodeConnection = {
  __typename?: 'ObjectiveGroupNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ObjectiveGroupNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ObjectiveGroupNode` and its cursor. */
export type ObjectiveGroupNodeEdge = {
  __typename?: 'ObjectiveGroupNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ObjectiveGroupNode>;
};

export type ObjectiveNode = Node & {
  __typename?: 'ObjectiveNode';
  group: ObjectiveGroupNode;
  hiddenFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
  hiddenForSnapshots: SnapshotNodeConnection;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  mine?: Maybe<Scalars['Boolean']['output']>;
  order?: Maybe<Scalars['Int']['output']>;
  owner?: Maybe<PrivateUserNode>;
  pk?: Maybe<Scalars['Int']['output']>;
  text: Scalars['String']['output'];
  userCreated?: Maybe<Scalars['Boolean']['output']>;
  visibleFor?: Maybe<Array<Maybe<SchoolClassNode>>>;
};

export type ObjectiveNodeHiddenForSnapshotsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type ObjectiveNodeConnection = {
  __typename?: 'ObjectiveNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<ObjectiveNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `ObjectiveNode` and its cursor. */
export type ObjectiveNodeEdge = {
  __typename?: 'ObjectiveNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<ObjectiveNode>;
};

/** An enumeration. */
export enum ObjectivesObjectiveGroupTitleChoices {
  /** Überfachliche Lernziele */
  Interdisciplinary = 'INTERDISCIPLINARY',
  /** Sprache & Kommunikation */
  LanguageCommunication = 'LANGUAGE_COMMUNICATION',
  /** Gesellschaft */
  Society = 'SOCIETY',
}

/** The Relay compliant `PageInfo` type, containing data necessary to paginate this connection. */
export type PageInfo = {
  __typename?: 'PageInfo';
  /** When paginating forwards, the cursor to continue. */
  endCursor?: Maybe<Scalars['String']['output']>;
  /** When paginating forwards, are there more items? */
  hasNextPage: Scalars['Boolean']['output'];
  /** When paginating backwards, are there more items? */
  hasPreviousPage: Scalars['Boolean']['output'];
  /** When paginating backwards, the cursor to continue. */
  startCursor?: Maybe<Scalars['String']['output']>;
};

export type PasswordUpdateInput = {
  newPassword?: InputMaybe<Scalars['String']['input']>;
  oldPassword?: InputMaybe<Scalars['String']['input']>;
};

export type PrivateUserNode = Node & {
  __typename?: 'PrivateUserNode';
  avatarUrl: Scalars['String']['output'];
  email: Scalars['String']['output'];
  expiryDate?: Maybe<Scalars['String']['output']>;
  firstName: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  isTeacher?: Maybe<Scalars['Boolean']['output']>;
  language?: Maybe<Scalars['String']['output']>;
  lastModule?: Maybe<ModuleNode>;
  lastModuleLevel?: Maybe<ModuleLevelNode>;
  lastName: Scalars['String']['output'];
  lastTopic?: Maybe<TopicNode>;
  oldClasses?: Maybe<Array<Maybe<SchoolClassNode>>>;
  onboardingVisited: Scalars['Boolean']['output'];
  permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  pk?: Maybe<Scalars['Int']['output']>;
  readOnly?: Maybe<Scalars['Boolean']['output']>;
  recentModules?: Maybe<ModuleNodeConnection>;
  schoolClasses?: Maybe<Array<Maybe<SchoolClassNode>>>;
  selectedClass?: Maybe<SchoolClassNode>;
  team?: Maybe<TeamNode>;
  /** Erforderlich. 150 Zeichen oder weniger. Nur Buchstaben, Ziffern und @/./+/-/_. */
  username: Scalars['String']['output'];
};

export type PrivateUserNodeRecentModulesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  orderBy?: InputMaybe<Scalars['String']['input']>;
  recentModules?: InputMaybe<Scalars['ID']['input']>;
};

export type PrivateUserNodeConnection = {
  __typename?: 'PrivateUserNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<PrivateUserNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `PrivateUserNode` and its cursor. */
export type PrivateUserNodeEdge = {
  __typename?: 'PrivateUserNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<PrivateUserNode>;
};

export type ProjectEntryNode = Node & {
  __typename?: 'ProjectEntryNode';
  created: Scalars['DateTime']['output'];
  description: Scalars['String']['output'];
  documentUrl: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  project: ProjectNode;
};

export type ProjectNode = Node & {
  __typename?: 'ProjectNode';
  appearance: Scalars['String']['output'];
  description?: Maybe<Scalars['String']['output']>;
  entries?: Maybe<Array<Maybe<ProjectEntryNode>>>;
  entriesCount?: Maybe<Scalars['Int']['output']>;
  final: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  objectives: Scalars['String']['output'];
  owner?: Maybe<PublicUserNode>;
  pk?: Maybe<Scalars['Int']['output']>;
  schoolClass?: Maybe<SchoolClassNode>;
  slug: Scalars['String']['output'];
  student: PrivateUserNode;
  title: Scalars['String']['output'];
};

export type PublicUserNode = Node & {
  __typename?: 'PublicUserNode';
  avatarUrl: Scalars['String']['output'];
  firstName: Scalars['String']['output'];
  fullName: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  isMe?: Maybe<Scalars['Boolean']['output']>;
  lastName: Scalars['String']['output'];
};

export type Query = {
  __typename?: 'Query';
  _debug?: Maybe<DjangoDebug>;
  allRoomEntries?: Maybe<RoomEntryNodeConnection>;
  allUsers?: Maybe<PrivateUserNodeConnection>;
  assignment?: Maybe<AssignmentNode>;
  assignments?: Maybe<Array<Maybe<AssignmentNode>>>;
  chapter?: Maybe<ChapterNode>;
  chapters?: Maybe<ChapterNodeConnection>;
  contentBlock?: Maybe<ContentBlockNode>;
  instrument?: Maybe<InstrumentNode>;
  instrumentCategories?: Maybe<Array<Maybe<InstrumentCategoryNode>>>;
  instrumentTypes?: Maybe<Array<Maybe<InstrumentTypeNode>>>;
  instruments?: Maybe<Array<Maybe<InstrumentNode>>>;
  me?: Maybe<PrivateUserNode>;
  module?: Maybe<ModuleNode>;
  moduleCategories?: Maybe<Array<Maybe<ModuleCategoryNode>>>;
  moduleCategory?: Maybe<ModuleCategoryNode>;
  moduleLevel?: Maybe<ModuleLevelNode>;
  moduleLevels?: Maybe<Array<Maybe<ModuleLevelNode>>>;
  moduleRoom?: Maybe<RoomNode>;
  modules?: Maybe<ModuleConnection>;
  myActivity?: Maybe<ModuleNodeConnection>;
  myInstrumentActivity?: Maybe<InstrumentNodeConnection>;
  newsTeasers?: Maybe<Array<Maybe<NewsTeaserNode>>>;
  node?: Maybe<Node>;
  objectiveGroup?: Maybe<ObjectiveGroupNode>;
  objectiveGroups?: Maybe<ObjectiveGroupNodeConnection>;
  project?: Maybe<ProjectNode>;
  projects?: Maybe<Array<Maybe<ProjectNode>>>;
  room?: Maybe<RoomNode>;
  roomEntry?: Maybe<RoomEntryNode>;
  rooms?: Maybe<Array<Maybe<RoomNode>>>;
  snapshot?: Maybe<SnapshotNode>;
  studentSubmission?: Maybe<StudentSubmissionNode>;
  survey?: Maybe<SurveyNode>;
  surveys?: Maybe<SurveyNodeConnection>;
  topic?: Maybe<TopicOr404Node>;
  topics?: Maybe<TopicConnection>;
};

export type QueryAllRoomEntriesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryAllUsersArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  email?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  username?: InputMaybe<Scalars['String']['input']>;
};

export type QueryAssignmentArgs = {
  id: Scalars['ID']['input'];
};

export type QueryChapterArgs = {
  id: Scalars['ID']['input'];
};

export type QueryChaptersArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  title?: InputMaybe<Scalars['String']['input']>;
};

export type QueryContentBlockArgs = {
  id: Scalars['ID']['input'];
};

export type QueryInstrumentArgs = {
  id?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryModuleArgs = {
  id?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryModuleCategoryArgs = {
  id: Scalars['ID']['input'];
};

export type QueryModuleLevelArgs = {
  id: Scalars['ID']['input'];
};

export type QueryModuleRoomArgs = {
  classId?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryModulesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

export type QueryMyActivityArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  slug_Icontains?: InputMaybe<Scalars['String']['input']>;
  slug_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  title?: InputMaybe<Scalars['String']['input']>;
  title_Icontains?: InputMaybe<Scalars['String']['input']>;
  title_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type QueryMyInstrumentActivityArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryNodeArgs = {
  id: Scalars['ID']['input'];
};

export type QueryObjectiveGroupArgs = {
  id: Scalars['ID']['input'];
};

export type QueryObjectiveGroupsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  module_Slug?: InputMaybe<Scalars['String']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  title?: InputMaybe<ObjectivesObjectiveGroupTitleChoices>;
};

export type QueryProjectArgs = {
  id?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryRoomArgs = {
  appearance?: InputMaybe<Scalars['String']['input']>;
  id?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryRoomEntryArgs = {
  id?: InputMaybe<Scalars['ID']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QuerySnapshotArgs = {
  id: Scalars['ID']['input'];
};

export type QueryStudentSubmissionArgs = {
  id: Scalars['ID']['input'];
};

export type QuerySurveyArgs = {
  id?: InputMaybe<Scalars['ID']['input']>;
};

export type QuerySurveysArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type QueryTopicArgs = {
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type QueryTopicsArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
};

export type RedeemCouponResult = InvalidCoupon | Success;

export type RoomEntryNode = Node & {
  __typename?: 'RoomEntryNode';
  author?: Maybe<PublicUserNode>;
  comments?: Maybe<Array<Maybe<CommentNode>>>;
  contents?: Maybe<Scalars['GenericStreamFieldType']['output']>;
  description?: Maybe<Scalars['String']['output']>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
  room: RoomNode;
  slug: Scalars['String']['output'];
  title: Scalars['String']['output'];
};

export type RoomEntryNodeConnection = {
  __typename?: 'RoomEntryNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<RoomEntryNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `RoomEntryNode` and its cursor. */
export type RoomEntryNodeEdge = {
  __typename?: 'RoomEntryNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<RoomEntryNode>;
};

export type RoomNode = Node & {
  __typename?: 'RoomNode';
  appearance: Scalars['String']['output'];
  description?: Maybe<Scalars['String']['output']>;
  entryCount?: Maybe<Scalars['Int']['output']>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
  restricted: Scalars['Boolean']['output'];
  roomEntries: RoomEntryNodeConnection;
  schoolClass: SchoolClassNode;
  slug: Scalars['String']['output'];
  title: Scalars['String']['output'];
  userCreated: Scalars['Boolean']['output'];
};

export type RoomNodeRoomEntriesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type SchoolClassInput = {
  id?: InputMaybe<Scalars['ID']['input']>;
  name?: InputMaybe<Scalars['String']['input']>;
};

export type SchoolClassNode = Node & {
  __typename?: 'SchoolClassNode';
  code?: Maybe<Scalars['String']['output']>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  members?: Maybe<Array<Maybe<ClassMemberNode>>>;
  name: Scalars['String']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
  readOnly?: Maybe<Scalars['Boolean']['output']>;
};

export type ShareSnapshotInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  shared: Scalars['Boolean']['input'];
  snapshot: Scalars['ID']['input'];
};

export type ShareSnapshotPayload = {
  __typename?: 'ShareSnapshotPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  snapshot?: Maybe<SnapshotNode>;
  success: Scalars['Boolean']['output'];
};

export type SnapshotChangesNode = {
  __typename?: 'SnapshotChangesNode';
  hiddenContentBlocks: Scalars['Int']['output'];
  hiddenObjectives: Scalars['Int']['output'];
  newContentBlocks: Scalars['Int']['output'];
  newObjectives: Scalars['Int']['output'];
};

export type SnapshotChapterNode = ChapterInterface &
  Node & {
    __typename?: 'SnapshotChapterNode';
    contentBlocks?: Maybe<Array<Maybe<SnapshotContentBlockNode>>>;
    description?: Maybe<Scalars['String']['output']>;
    descriptionHidden?: Maybe<Scalars['Boolean']['output']>;
    /** The ID of the object */
    id: Scalars['ID']['output'];
    title?: Maybe<Scalars['String']['output']>;
    titleHidden?: Maybe<Scalars['Boolean']['output']>;
  };

export type SnapshotContentBlockNode = ContentBlockInterface &
  Node & {
    __typename?: 'SnapshotContentBlockNode';
    contents?: Maybe<Scalars['GenericStreamFieldType']['output']>;
    hidden?: Maybe<Scalars['Boolean']['output']>;
    /** The ID of the object */
    id: Scalars['ID']['output'];
    title?: Maybe<Scalars['String']['output']>;
    type: Scalars['String']['output'];
  };

export type SnapshotNode = Node & {
  __typename?: 'SnapshotNode';
  changes?: Maybe<SnapshotChangesNode>;
  chapters?: Maybe<Array<Maybe<SnapshotChapterNode>>>;
  created: Scalars['DateTime']['output'];
  creator: Scalars['String']['output'];
  heroImage?: Maybe<Scalars['String']['output']>;
  hiddenContentBlocks: ContentBlockNodeConnection;
  hiddenObjectives: ObjectiveNodeConnection;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  metaTitle?: Maybe<Scalars['String']['output']>;
  mine?: Maybe<Scalars['Boolean']['output']>;
  module: ModuleNode;
  objectiveGroups?: Maybe<Array<Maybe<SnapshotObjectiveGroupNode>>>;
  shared: Scalars['Boolean']['output'];
  title?: Maybe<Scalars['String']['output']>;
};

export type SnapshotNodeHiddenContentBlocksArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  title?: InputMaybe<Scalars['String']['input']>;
};

export type SnapshotNodeHiddenObjectivesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  text?: InputMaybe<Scalars['String']['input']>;
};

export type SnapshotNodeConnection = {
  __typename?: 'SnapshotNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<SnapshotNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `SnapshotNode` and its cursor. */
export type SnapshotNodeEdge = {
  __typename?: 'SnapshotNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<SnapshotNode>;
};

export type SnapshotObjectiveGroupNode = Node & {
  __typename?: 'SnapshotObjectiveGroupNode';
  displayTitle: Scalars['String']['output'];
  hidden: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  objectives: Array<Maybe<SnapshotObjectiveNode>>;
  title: Scalars['String']['output'];
};

export type SnapshotObjectiveNode = Node & {
  __typename?: 'SnapshotObjectiveNode';
  hidden: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  text: Scalars['String']['output'];
};

export type SpellCheckInput = {
  assignment: Scalars['ID']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  text: Scalars['String']['input'];
};

export type SpellCheckPayload = {
  __typename?: 'SpellCheckPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  correct?: Maybe<Scalars['Boolean']['output']>;
  results?: Maybe<Array<Maybe<SpellCheckStepNode>>>;
};

export type SpellCheckStepNode = {
  __typename?: 'SpellCheckStepNode';
  affected?: Maybe<Scalars['String']['output']>;
  corrected?: Maybe<Scalars['String']['output']>;
  length?: Maybe<Scalars['Int']['output']>;
  offset?: Maybe<Scalars['Int']['output']>;
  sentence?: Maybe<Scalars['String']['output']>;
  sentenceOffset?: Maybe<Scalars['Int']['output']>;
};

export type StudentSubmissionNode = Node & {
  __typename?: 'StudentSubmissionNode';
  assignment: AssignmentNode;
  created: Scalars['DateTime']['output'];
  document: Scalars['String']['output'];
  final: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  modified: Scalars['DateTime']['output'];
  student: PrivateUserNode;
  submissionFeedback?: Maybe<SubmissionFeedbackNode>;
  text: Scalars['String']['output'];
};

export type StudentSubmissionNodeConnection = {
  __typename?: 'StudentSubmissionNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<StudentSubmissionNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `StudentSubmissionNode` and its cursor. */
export type StudentSubmissionNodeEdge = {
  __typename?: 'StudentSubmissionNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<StudentSubmissionNode>;
};

export type SubmissionFeedbackInput = {
  final?: InputMaybe<Scalars['Boolean']['input']>;
  id?: InputMaybe<Scalars['ID']['input']>;
  studentSubmission: Scalars['ID']['input'];
  text: Scalars['String']['input'];
};

export type SubmissionFeedbackNode = Node & {
  __typename?: 'SubmissionFeedbackNode';
  created: Scalars['DateTime']['output'];
  final: Scalars['Boolean']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  modified: Scalars['DateTime']['output'];
  studentSubmission: StudentSubmissionNode;
  teacher: PrivateUserNode;
  text: Scalars['String']['output'];
};

export type Success = SuccessNode & {
  __typename?: 'Success';
  message?: Maybe<Scalars['String']['output']>;
};

export type SuccessNode = {
  message?: Maybe<Scalars['String']['output']>;
};

export type SurveyNode = Node & {
  __typename?: 'SurveyNode';
  answer?: Maybe<AnswerNode>;
  answers: AnswerNodeConnection;
  data: Scalars['JSONString']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  module?: Maybe<ModuleNode>;
  pk?: Maybe<Scalars['Int']['output']>;
  title: Scalars['String']['output'];
};

export type SurveyNodeAnswersArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};

export type SurveyNodeConnection = {
  __typename?: 'SurveyNodeConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<SurveyNodeEdge>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `SurveyNode` and its cursor. */
export type SurveyNodeEdge = {
  __typename?: 'SurveyNodeEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<SurveyNode>;
};

export type SyncModuleVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  module: Scalars['String']['input'];
  schoolClass: Scalars['ID']['input'];
  templateSchoolClass: Scalars['ID']['input'];
};

export type SyncModuleVisibilityPayload = {
  __typename?: 'SyncModuleVisibilityPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type TeamNode = Node & {
  __typename?: 'TeamNode';
  code?: Maybe<Scalars['String']['output']>;
  creator?: Maybe<PrivateUserNode>;
  /** The ID of the object */
  id: Scalars['ID']['output'];
  isDeleted: Scalars['Boolean']['output'];
  members?: Maybe<Array<Maybe<PublicUserNode>>>;
  name: Scalars['String']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
};

export type TopicConnection = {
  __typename?: 'TopicConnection';
  /** Contains the nodes in this connection. */
  edges: Array<Maybe<TopicEdge>>;
  nodes?: Maybe<Array<Maybe<TopicNode>>>;
  /** Pagination data for this connection. */
  pageInfo: PageInfo;
};

/** A Relay edge containing a `Topic` and its cursor. */
export type TopicEdge = {
  __typename?: 'TopicEdge';
  /** A cursor for use in pagination */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge */
  node?: Maybe<TopicNode>;
};

export type TopicNode = Node & {
  __typename?: 'TopicNode';
  description: Scalars['String']['output'];
  /** The ID of the object */
  id: Scalars['ID']['output'];
  instructions?: Maybe<Scalars['String']['output']>;
  modules?: Maybe<ModuleNodeConnection>;
  /** Order of the topic */
  order: Scalars['Int']['output'];
  pk?: Maybe<Scalars['Int']['output']>;
  /** Der Name der Seite, wie er in URLs angezeigt werden soll, z.B. http://domain.com/blog/[my-slug]/ */
  slug: Scalars['String']['output'];
  teaser: Scalars['String']['output'];
  /** Der Seitentitel, der öffentlich angezeigt werden soll */
  title: Scalars['String']['output'];
  vimeoId?: Maybe<Scalars['String']['output']>;
};

export type TopicNodeModulesArgs = {
  after?: InputMaybe<Scalars['String']['input']>;
  before?: InputMaybe<Scalars['String']['input']>;
  first?: InputMaybe<Scalars['Int']['input']>;
  last?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
  slug_Icontains?: InputMaybe<Scalars['String']['input']>;
  slug_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  title?: InputMaybe<Scalars['String']['input']>;
  title_Icontains?: InputMaybe<Scalars['String']['input']>;
  title_In?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};

export type TopicOr404Node = NotFound | TopicNode;

export type UpdateAnswerArgument = {
  data: Scalars['String']['input'];
  surveyId: Scalars['ID']['input'];
};

export type UpdateAnswerInput = {
  answer?: InputMaybe<UpdateAnswerArgument>;
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateAnswerPayload = {
  __typename?: 'UpdateAnswerPayload';
  answer?: Maybe<AnswerNode>;
  clientMutationId?: Maybe<Scalars['String']['output']>;
};

export type UpdateAssignmentInput = {
  assignment?: InputMaybe<AssignmentInput>;
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateAssignmentPayload = {
  __typename?: 'UpdateAssignmentPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  submission?: Maybe<StudentSubmissionNode>;
  successful?: Maybe<Scalars['Boolean']['output']>;
  updatedAssignment?: Maybe<AssignmentNode>;
};

export type UpdateAvatarInput = {
  avatarUrl?: InputMaybe<Scalars['String']['input']>;
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateAvatarPayload = {
  __typename?: 'UpdateAvatarPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<UpdateError>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateChapterBookmarkInput = {
  bookmarked: Scalars['Boolean']['input'];
  chapter: Scalars['ID']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateChapterBookmarkPayload = {
  __typename?: 'UpdateChapterBookmarkPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateChapterVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  type: Scalars['String']['input'];
  visibility?: InputMaybe<Array<InputMaybe<UserGroupBlockVisibility>>>;
};

export type UpdateChapterVisibilityPayload = {
  __typename?: 'UpdateChapterVisibilityPayload';
  chapter?: Maybe<ChapterNode>;
  clientMutationId?: Maybe<Scalars['String']['output']>;
};

export type UpdateContentBookmarkInput = {
  bookmarked: Scalars['Boolean']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  contentBlock: Scalars['ID']['input'];
  uuid: Scalars['UUID']['input'];
};

export type UpdateContentBookmarkPayload = {
  __typename?: 'UpdateContentBookmarkPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateError = {
  __typename?: 'UpdateError';
  errors?: Maybe<Array<Maybe<FieldError>>>;
  field?: Maybe<Scalars['String']['output']>;
};

export type UpdateInstrumentBookmarkInput = {
  bookmarked: Scalars['Boolean']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  instrument: Scalars['String']['input'];
  uuid: Scalars['UUID']['input'];
};

export type UpdateInstrumentBookmarkPayload = {
  __typename?: 'UpdateInstrumentBookmarkPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateLastModuleInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id?: InputMaybe<Scalars['ID']['input']>;
};

export type UpdateLastModuleLevelInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id?: InputMaybe<Scalars['ID']['input']>;
};

export type UpdateLastModuleLevelPayload = {
  __typename?: 'UpdateLastModuleLevelPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  user?: Maybe<PrivateUserNode>;
};

export type UpdateLastModulePayload = {
  __typename?: 'UpdateLastModulePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  lastModule?: Maybe<ModuleNode>;
};

export type UpdateLastTopicInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id?: InputMaybe<Scalars['ID']['input']>;
};

export type UpdateLastTopicPayload = {
  __typename?: 'UpdateLastTopicPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  topic?: Maybe<TopicNode>;
};

export type UpdateModuleBookmarkInput = {
  bookmarked: Scalars['Boolean']['input'];
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  module: Scalars['String']['input'];
};

export type UpdateModuleBookmarkPayload = {
  __typename?: 'UpdateModuleBookmarkPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateNoteArgument = {
  id: Scalars['ID']['input'];
  text: Scalars['String']['input'];
};

export type UpdateNoteInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  note?: InputMaybe<UpdateNoteArgument>;
};

export type UpdateNotePayload = {
  __typename?: 'UpdateNotePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  note?: Maybe<NoteNode>;
};

export type UpdateObjectiveGroupVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  /** The ID of the objective group */
  id: Scalars['ID']['input'];
  visibility?: InputMaybe<Array<InputMaybe<UserGroupBlockVisibility>>>;
};

export type UpdateObjectiveGroupVisibilityPayload = {
  __typename?: 'UpdateObjectiveGroupVisibilityPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  objectiveGroup?: Maybe<ObjectiveGroupNode>;
};

export type UpdateObjectiveVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  /** The ID of the objective */
  id: Scalars['ID']['input'];
  visibility?: InputMaybe<Array<InputMaybe<UserGroupBlockVisibility>>>;
};

export type UpdateObjectiveVisibilityPayload = {
  __typename?: 'UpdateObjectiveVisibilityPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  objective?: Maybe<ObjectiveNode>;
};

export type UpdateOnboardingProgress = {
  __typename?: 'UpdateOnboardingProgress';
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdatePasswordInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  passwordInput?: InputMaybe<PasswordUpdateInput>;
};

export type UpdatePasswordPayload = {
  __typename?: 'UpdatePasswordPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<UpdateError>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateProjectArgument = {
  appearance?: InputMaybe<Scalars['String']['input']>;
  description?: InputMaybe<Scalars['String']['input']>;
  final?: InputMaybe<Scalars['Boolean']['input']>;
  objectives?: InputMaybe<Scalars['String']['input']>;
  slug: Scalars['String']['input'];
  title?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateProjectEntryArgument = {
  description?: InputMaybe<Scalars['String']['input']>;
  documentUrl?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type UpdateProjectEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  projectEntry?: InputMaybe<UpdateProjectEntryArgument>;
};

export type UpdateProjectEntryPayload = {
  __typename?: 'UpdateProjectEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  projectEntry?: Maybe<ProjectEntryNode>;
};

export type UpdateProjectInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  project?: InputMaybe<UpdateProjectArgument>;
};

export type UpdateProjectPayload = {
  __typename?: 'UpdateProjectPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  project?: Maybe<ProjectNode>;
};

export type UpdateProjectSharedStateInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  shared?: InputMaybe<Scalars['Boolean']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateProjectSharedStatePayload = {
  __typename?: 'UpdateProjectSharedStatePayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  shared?: Maybe<Scalars['Boolean']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateRoomArgument = {
  appearance?: InputMaybe<Scalars['String']['input']>;
  description?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  schoolClass?: InputMaybe<SchoolClassInput>;
  title?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateRoomEntryArgument = {
  contents?: InputMaybe<Array<InputMaybe<ContentElementInput>>>;
  slug: Scalars['String']['input'];
  title: Scalars['String']['input'];
};

export type UpdateRoomEntryInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  roomEntry?: InputMaybe<UpdateRoomEntryArgument>;
};

export type UpdateRoomEntryPayload = {
  __typename?: 'UpdateRoomEntryPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  roomEntry?: Maybe<RoomEntryNode>;
};

export type UpdateRoomInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  room?: InputMaybe<UpdateRoomArgument>;
};

export type UpdateRoomPayload = {
  __typename?: 'UpdateRoomPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  room?: Maybe<RoomNode>;
};

export type UpdateRoomVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  restricted: Scalars['Boolean']['input'];
};

export type UpdateRoomVisibilityPayload = {
  __typename?: 'UpdateRoomVisibilityPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  room?: Maybe<RoomNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateSchoolClassInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  name?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateSchoolClassPayload = {
  __typename?: 'UpdateSchoolClassPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  schoolClass?: Maybe<SchoolClassNode>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateSettingInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
};

export type UpdateSettingPayload = {
  __typename?: 'UpdateSettingPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<UpdateError>>>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateSnapshotInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  title?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateSnapshotPayload = {
  __typename?: 'UpdateSnapshotPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  snapshot?: Maybe<UpdateSnapshotResult>;
};

export type UpdateSnapshotResult = NotOwner | SnapshotNode;

export type UpdateSolutionVisibilityInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  enabled?: InputMaybe<Scalars['Boolean']['input']>;
  slug?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateSolutionVisibilityPayload = {
  __typename?: 'UpdateSolutionVisibilityPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  solutionsEnabled?: Maybe<Scalars['Boolean']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
};

export type UpdateSubmissionFeedbackInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  submissionFeedback?: InputMaybe<SubmissionFeedbackInput>;
};

export type UpdateSubmissionFeedbackPayload = {
  __typename?: 'UpdateSubmissionFeedbackPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  successful?: Maybe<Scalars['Boolean']['output']>;
  updatedSubmissionFeedback?: Maybe<SubmissionFeedbackNode>;
};

export type UpdateTeamInput = {
  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  name?: InputMaybe<Scalars['String']['input']>;
};

export type UpdateTeamPayload = {
  __typename?: 'UpdateTeamPayload';
  clientMutationId?: Maybe<Scalars['String']['output']>;
  success?: Maybe<Scalars['Boolean']['output']>;
  team?: Maybe<TeamNode>;
};

export type UserGroupBlockVisibility = {
  hidden: Scalars['Boolean']['input'];
  schoolClassId: Scalars['ID']['input'];
};

export type LanguageQueryQueryVariables = Exact<{ [key: string]: never }>;

export type LanguageQueryQuery = {
  __typename?: 'Query';
  me?: { __typename?: 'PrivateUserNode'; language?: string | null } | null;
};

export type SetLanguageMutationVariables = Exact<{
  language: Scalars['String']['input'];
}>;

export type SetLanguageMutation = {
  __typename?: 'Mutation';
  setLanguage?: { __typename?: 'PrivateUserNode'; language?: string | null } | null;
};

export type ReadOnlyQueryQueryVariables = Exact<{ [key: string]: never }>;

export type ReadOnlyQueryQuery = {
  __typename?: 'Query';
  me?: {
    __typename?: 'PrivateUserNode';
    readOnly?: boolean | null;
    selectedClass?: { __typename?: 'SchoolClassNode'; readOnly?: boolean | null } | null;
  } | null;
};

export type ModuleLevelFragmentFragment = {
  __typename?: 'ModuleLevelNode';
  name: string;
  id: string;
  filterAttributeType: BooksModuleLevelFilterAttributeTypeChoices;
} & { ' $fragmentName'?: 'ModuleLevelFragmentFragment' };

export type ModuleFilterQueryQueryVariables = Exact<{ [key: string]: never }>;

export type ModuleFilterQueryQuery = {
  __typename?: 'Query';
  moduleLevels?: Array<
    | ({ __typename?: 'ModuleLevelNode' } & {
        ' $fragmentRefs'?: { ModuleLevelFragmentFragment: ModuleLevelFragmentFragment };
      })
    | null
  > | null;
  moduleCategories?: Array<{
    __typename?: 'ModuleCategoryNode';
    name: string;
    id: string;
    filterAttributeType: BooksModuleCategoryFilterAttributeTypeChoices;
  } | null> | null;
  me?: { __typename?: 'PrivateUserNode'; language?: string | null } | null;
};

export type UpdateLastModuleLevelMutationMutationVariables = Exact<{
  input: UpdateLastModuleLevelInput;
}>;

export type UpdateLastModuleLevelMutationMutation = {
  __typename?: 'Mutation';
  updateLastModuleLevel?: {
    __typename?: 'UpdateLastModuleLevelPayload';
    clientMutationId?: string | null;
    user?: {
      __typename?: 'PrivateUserNode';
      username: string;
      id: string;
      lastModuleLevel?:
        | ({ __typename?: 'ModuleLevelNode' } & {
            ' $fragmentRefs'?: { ModuleLevelFragmentFragment: ModuleLevelFragmentFragment };
          })
        | null;
    } | null;
  } | null;
};

export type ModuleTitleQueryQueryVariables = Exact<{
  slug?: InputMaybe<Scalars['String']['input']>;
}>;

export type ModuleTitleQueryQuery = {
  __typename?: 'Query';
  module?: { __typename?: 'ModuleNode'; title: string } | null;
};

export type SnapshotListItemFragment = { __typename?: 'SnapshotNode'; shared: boolean } & {
  ' $fragmentName'?: 'SnapshotListItemFragment';
};

export type SnapshotTitleFragmentFragment = { __typename?: 'SnapshotNode'; title?: string | null } & {
  ' $fragmentName'?: 'SnapshotTitleFragmentFragment';
};

export type SnapshotDetailsFragmentFragment = {
  __typename?: 'SnapshotNode';
  id: string;
  title?: string | null;
  shared: boolean;
  created: any;
  creator: string;
  mine?: boolean | null;
} & { ' $fragmentName'?: 'SnapshotDetailsFragmentFragment' };

export type ModuleEditModeQueryQueryVariables = Exact<{
  slug?: InputMaybe<Scalars['String']['input']>;
}>;

export type ModuleEditModeQueryQuery = {
  __typename?: 'Query';
  module?: { __typename?: 'ModuleNode'; inEditMode: boolean; slug: string } | null;
};

export type ChapterQueryQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;

export type ChapterQueryQuery = {
  __typename?: 'Query';
  chapter?: { __typename?: 'ChapterNode'; path?: string | null } | null;
};

export type ContentBlockQueryQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;

export type ContentBlockQueryQuery = {
  __typename?: 'Query';
  contentBlock?: { __typename?: 'ContentBlockNode'; path?: string | null } | null;
};

export type MeLanguageQueryVariables = Exact<{ [key: string]: never }>;

export type MeLanguageQuery = {
  __typename?: 'Query';
  me?: { __typename?: 'PrivateUserNode'; language?: string | null } | null;
};

export type ModuleSnapshotsQueryQueryVariables = Exact<{
  slug: Scalars['String']['input'];
}>;

export type ModuleSnapshotsQueryQuery = {
  __typename?: 'Query';
  module?: {
    __typename?: 'ModuleNode';
    id: string;
    title: string;
    metaTitle: string;
    slug: string;
    topic?: { __typename?: 'TopicNode'; title: string } | null;
    snapshots?: Array<
      | ({ __typename?: 'SnapshotNode' } & {
          ' $fragmentRefs'?: { SnapshotDetailsFragmentFragment: SnapshotDetailsFragmentFragment };
        })
      | null
    > | null;
  } | null;
};

export type ModuleSolutionsQueryVariables = Exact<{
  slug?: InputMaybe<Scalars['String']['input']>;
}>;

export type ModuleSolutionsQuery = {
  __typename?: 'Query';
  module?: { __typename?: 'ModuleNode'; solutionsEnabled?: boolean | null; slug: string } | null;
};

export const ModuleLevelFragmentFragmentDoc = {
  kind: 'Document',
  definitions: [
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'ModuleLevelFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'ModuleLevelNode' } },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          { kind: 'Field', name: { kind: 'Name', value: 'name' } },
          { kind: 'Field', name: { kind: 'Name', value: 'id' } },
          { kind: 'Field', name: { kind: 'Name', value: 'filterAttributeType' } },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleLevelFragmentFragment, unknown>;
export const SnapshotListItemFragmentDoc = {
  kind: 'Document',
  definitions: [
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'SnapshotListItem' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'SnapshotNode' } },
      selectionSet: { kind: 'SelectionSet', selections: [{ kind: 'Field', name: { kind: 'Name', value: 'shared' } }] },
    },
  ],
} as unknown as DocumentNode<SnapshotListItemFragment, unknown>;
export const SnapshotTitleFragmentFragmentDoc = {
  kind: 'Document',
  definitions: [
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'SnapshotTitleFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'SnapshotNode' } },
      selectionSet: { kind: 'SelectionSet', selections: [{ kind: 'Field', name: { kind: 'Name', value: 'title' } }] },
    },
  ],
} as unknown as DocumentNode<SnapshotTitleFragmentFragment, unknown>;
export const SnapshotDetailsFragmentFragmentDoc = {
  kind: 'Document',
  definitions: [
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'SnapshotDetailsFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'SnapshotNode' } },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          { kind: 'Field', name: { kind: 'Name', value: 'id' } },
          { kind: 'Field', name: { kind: 'Name', value: 'title' } },
          { kind: 'Field', name: { kind: 'Name', value: 'shared' } },
          { kind: 'Field', name: { kind: 'Name', value: 'created' } },
          { kind: 'Field', name: { kind: 'Name', value: 'creator' } },
          { kind: 'Field', name: { kind: 'Name', value: 'mine' } },
        ],
      },
    },
  ],
} as unknown as DocumentNode<SnapshotDetailsFragmentFragment, unknown>;
export const LanguageQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'LanguageQuery' },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'me' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'language' },
                  directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'client' } }],
                },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<LanguageQueryQuery, LanguageQueryQueryVariables>;
export const SetLanguageDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'mutation',
      name: { kind: 'Name', value: 'SetLanguage' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'language' } },
          type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'setLanguage' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'language' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'language' } },
              },
            ],
            directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'client' } }],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [{ kind: 'Field', name: { kind: 'Name', value: 'language' } }],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<SetLanguageMutation, SetLanguageMutationVariables>;
export const ReadOnlyQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ReadOnlyQuery' },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'me' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'readOnly' } },
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'selectedClass' },
                  selectionSet: {
                    kind: 'SelectionSet',
                    selections: [{ kind: 'Field', name: { kind: 'Name', value: 'readOnly' } }],
                  },
                },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ReadOnlyQueryQuery, ReadOnlyQueryQueryVariables>;
export const ModuleFilterQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ModuleFilterQuery' },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'moduleLevels' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [{ kind: 'FragmentSpread', name: { kind: 'Name', value: 'ModuleLevelFragment' } }],
            },
          },
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'moduleCategories' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'name' } },
                { kind: 'Field', name: { kind: 'Name', value: 'id' } },
                { kind: 'Field', name: { kind: 'Name', value: 'filterAttributeType' } },
              ],
            },
          },
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'me' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'language' },
                  directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'client' } }],
                },
              ],
            },
          },
        ],
      },
    },
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'ModuleLevelFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'ModuleLevelNode' } },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          { kind: 'Field', name: { kind: 'Name', value: 'name' } },
          { kind: 'Field', name: { kind: 'Name', value: 'id' } },
          { kind: 'Field', name: { kind: 'Name', value: 'filterAttributeType' } },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleFilterQueryQuery, ModuleFilterQueryQueryVariables>;
export const UpdateLastModuleLevelMutationDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'mutation',
      name: { kind: 'Name', value: 'UpdateLastModuleLevelMutation' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'input' } },
          type: {
            kind: 'NonNullType',
            type: { kind: 'NamedType', name: { kind: 'Name', value: 'UpdateLastModuleLevelInput' } },
          },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'updateLastModuleLevel' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'input' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'input' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'clientMutationId' } },
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'user' },
                  selectionSet: {
                    kind: 'SelectionSet',
                    selections: [
                      { kind: 'Field', name: { kind: 'Name', value: 'username' } },
                      { kind: 'Field', name: { kind: 'Name', value: 'id' } },
                      {
                        kind: 'Field',
                        name: { kind: 'Name', value: 'lastModuleLevel' },
                        selectionSet: {
                          kind: 'SelectionSet',
                          selections: [
                            { kind: 'FragmentSpread', name: { kind: 'Name', value: 'ModuleLevelFragment' } },
                          ],
                        },
                      },
                    ],
                  },
                },
              ],
            },
          },
        ],
      },
    },
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'ModuleLevelFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'ModuleLevelNode' } },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          { kind: 'Field', name: { kind: 'Name', value: 'name' } },
          { kind: 'Field', name: { kind: 'Name', value: 'id' } },
          { kind: 'Field', name: { kind: 'Name', value: 'filterAttributeType' } },
        ],
      },
    },
  ],
} as unknown as DocumentNode<UpdateLastModuleLevelMutationMutation, UpdateLastModuleLevelMutationMutationVariables>;
export const ModuleTitleQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ModuleTitleQuery' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
          type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'module' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'slug' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [{ kind: 'Field', name: { kind: 'Name', value: 'title' } }],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleTitleQueryQuery, ModuleTitleQueryQueryVariables>;
export const ModuleEditModeQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ModuleEditModeQuery' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
          type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'module' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'slug' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'inEditMode' },
                  directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'client' } }],
                },
                { kind: 'Field', name: { kind: 'Name', value: 'slug' } },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleEditModeQueryQuery, ModuleEditModeQueryQueryVariables>;
export const ChapterQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ChapterQuery' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
          type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'ID' } } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'chapter' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'id' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [{ kind: 'Field', name: { kind: 'Name', value: 'path' } }],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ChapterQueryQuery, ChapterQueryQueryVariables>;
export const ContentBlockQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ContentBlockQuery' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
          type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'ID' } } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'contentBlock' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'id' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [{ kind: 'Field', name: { kind: 'Name', value: 'path' } }],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ContentBlockQueryQuery, ContentBlockQueryQueryVariables>;
export const MeLanguageDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'MeLanguage' },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'me' },
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'language' },
                  directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'client' } }],
                },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<MeLanguageQuery, MeLanguageQueryVariables>;
export const ModuleSnapshotsQueryDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ModuleSnapshotsQuery' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
          type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'module' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'slug' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'id' } },
                { kind: 'Field', name: { kind: 'Name', value: 'title' } },
                { kind: 'Field', name: { kind: 'Name', value: 'metaTitle' } },
                { kind: 'Field', name: { kind: 'Name', value: 'slug' } },
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'topic' },
                  selectionSet: {
                    kind: 'SelectionSet',
                    selections: [{ kind: 'Field', name: { kind: 'Name', value: 'title' } }],
                  },
                },
                {
                  kind: 'Field',
                  name: { kind: 'Name', value: 'snapshots' },
                  selectionSet: {
                    kind: 'SelectionSet',
                    selections: [{ kind: 'FragmentSpread', name: { kind: 'Name', value: 'SnapshotDetailsFragment' } }],
                  },
                },
              ],
            },
          },
        ],
      },
    },
    {
      kind: 'FragmentDefinition',
      name: { kind: 'Name', value: 'SnapshotDetailsFragment' },
      typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'SnapshotNode' } },
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          { kind: 'Field', name: { kind: 'Name', value: 'id' } },
          { kind: 'Field', name: { kind: 'Name', value: 'title' } },
          { kind: 'Field', name: { kind: 'Name', value: 'shared' } },
          { kind: 'Field', name: { kind: 'Name', value: 'created' } },
          { kind: 'Field', name: { kind: 'Name', value: 'creator' } },
          { kind: 'Field', name: { kind: 'Name', value: 'mine' } },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleSnapshotsQueryQuery, ModuleSnapshotsQueryQueryVariables>;
export const ModuleSolutionsDocument = {
  kind: 'Document',
  definitions: [
    {
      kind: 'OperationDefinition',
      operation: 'query',
      name: { kind: 'Name', value: 'ModuleSolutions' },
      variableDefinitions: [
        {
          kind: 'VariableDefinition',
          variable: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
          type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } },
        },
      ],
      selectionSet: {
        kind: 'SelectionSet',
        selections: [
          {
            kind: 'Field',
            name: { kind: 'Name', value: 'module' },
            arguments: [
              {
                kind: 'Argument',
                name: { kind: 'Name', value: 'slug' },
                value: { kind: 'Variable', name: { kind: 'Name', value: 'slug' } },
              },
            ],
            selectionSet: {
              kind: 'SelectionSet',
              selections: [
                { kind: 'Field', name: { kind: 'Name', value: 'solutionsEnabled' } },
                { kind: 'Field', name: { kind: 'Name', value: 'slug' } },
              ],
            },
          },
        ],
      },
    },
  ],
} as unknown as DocumentNode<ModuleSolutionsQuery, ModuleSolutionsQueryVariables>;
