schema.graphql

# This file is automatically generated by Keystone, do not modify it manually.
# Modify your Keystone config when you want to change this.

type User {
  id: ID!
  name: String
  email: String
  emailVerified: Boolean
  emailVerificationToken: String
  emailVerificationTokenExpiry: DateTime
  provider: String
  password: PasswordState
  subjectId: String
  createdAt: DateTime
  account: Account
  role: String
}

scalar DateTime @specifiedBy(url: "https://datatracker.ietf.org/doc/html/rfc3339#section-5.6")

type PasswordState {
  isSet: Boolean!
}

input UserWhereUniqueInput {
  id: ID
  subjectId: String
}

input UserWhereInput {
  AND: [UserWhereInput!]
  OR: [UserWhereInput!]
  NOT: [UserWhereInput!]
  id: IDFilter
  email: StringFilter
  emailVerified: BooleanFilter
  emailVerificationToken: StringFilter
  emailVerificationTokenExpiry: DateTimeNullableFilter
  provider: StringFilter
  password: PasswordFilter
  subjectId: StringFilter
  createdAt: DateTimeNullableFilter
  account: AccountWhereInput
  role: StringFilter
}

input IDFilter {
  equals: ID
  in: [ID!]
  notIn: [ID!]
  lt: ID
  lte: ID
  gt: ID
  gte: ID
  not: IDFilter
}

input StringFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  mode: QueryMode
  not: NestedStringFilter
}

enum QueryMode {
  default
  insensitive
}

input NestedStringFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  not: NestedStringFilter
}

input BooleanFilter {
  equals: Boolean
  not: BooleanFilter
}

input DateTimeNullableFilter {
  equals: DateTime
  in: [DateTime!]
  notIn: [DateTime!]
  lt: DateTime
  lte: DateTime
  gt: DateTime
  gte: DateTime
  not: DateTimeNullableFilter
}

input PasswordFilter {
  isSet: Boolean!
}

input UserOrderByInput {
  id: OrderDirection
  email: OrderDirection
  emailVerified: OrderDirection
  emailVerificationToken: OrderDirection
  emailVerificationTokenExpiry: OrderDirection
  provider: OrderDirection
  subjectId: OrderDirection
  createdAt: OrderDirection
  role: OrderDirection
}

enum OrderDirection {
  asc
  desc
}

input UserUpdateInput {
  email: String
  emailVerified: Boolean
  emailVerificationToken: String
  emailVerificationTokenExpiry: DateTime
  provider: String
  password: String
  subjectId: String
  createdAt: DateTime
  account: AccountRelateToOneForUpdateInput
  role: String
}

input AccountRelateToOneForUpdateInput {
  create: AccountCreateInput
  connect: AccountWhereUniqueInput
  disconnect: Boolean
}

input UserUpdateArgs {
  where: UserWhereUniqueInput!
  data: UserUpdateInput!
}

input UserCreateInput {
  email: String
  emailVerified: Boolean
  emailVerificationToken: String
  emailVerificationTokenExpiry: DateTime
  provider: String
  password: String
  subjectId: String
  createdAt: DateTime
  account: AccountRelateToOneForCreateInput
  role: String
}

input AccountRelateToOneForCreateInput {
  create: AccountCreateInput
  connect: AccountWhereUniqueInput
}

type Account {
  id: ID!
  name: String
  user: User
  firstName: String
  surname: String
  phone: String
  secondContactName: String
  secondContactPhone: String
  students(where: StudentWhereInput! = {}, orderBy: [StudentOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: StudentWhereUniqueInput): [Student!]
  studentsCount(where: StudentWhereInput! = {}): Int
  bills(where: BillWhereInput! = {}, orderBy: [BillOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: BillWhereUniqueInput): [Bill!]
  billsCount(where: BillWhereInput! = {}): Int
  streetAddress: String
  suburb: String
  postcode: Int
  xeroId: String
  createdAt: DateTime
}

input AccountWhereUniqueInput {
  id: ID
  xeroId: String
}

input AccountWhereInput {
  AND: [AccountWhereInput!]
  OR: [AccountWhereInput!]
  NOT: [AccountWhereInput!]
  id: IDFilter
  user: UserWhereInput
  firstName: StringFilter
  surname: StringFilter
  phone: StringFilter
  secondContactName: StringFilter
  secondContactPhone: StringFilter
  students: StudentManyRelationFilter
  bills: BillManyRelationFilter
  streetAddress: StringFilter
  suburb: StringFilter
  postcode: IntFilter
  xeroId: StringNullableFilter
  createdAt: DateTimeNullableFilter
}

input StudentManyRelationFilter {
  every: StudentWhereInput
  some: StudentWhereInput
  none: StudentWhereInput
}

input BillManyRelationFilter {
  every: BillWhereInput
  some: BillWhereInput
  none: BillWhereInput
}

input IntFilter {
  equals: Int
  in: [Int!]
  notIn: [Int!]
  lt: Int
  lte: Int
  gt: Int
  gte: Int
  not: IntFilter
}

input StringNullableFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  mode: QueryMode
  not: StringNullableFilter
}

input AccountOrderByInput {
  id: OrderDirection
  firstName: OrderDirection
  surname: OrderDirection
  phone: OrderDirection
  secondContactName: OrderDirection
  secondContactPhone: OrderDirection
  streetAddress: OrderDirection
  suburb: OrderDirection
  postcode: OrderDirection
  xeroId: OrderDirection
  createdAt: OrderDirection
}

input AccountUpdateInput {
  user: UserRelateToOneForUpdateInput
  firstName: String
  surname: String
  phone: String
  secondContactName: String
  secondContactPhone: String
  students: StudentRelateToManyForUpdateInput
  bills: BillRelateToManyForUpdateInput
  streetAddress: String
  suburb: String
  postcode: Int
  xeroId: String
  createdAt: DateTime
}

input UserRelateToOneForUpdateInput {
  create: UserCreateInput
  connect: UserWhereUniqueInput
  disconnect: Boolean
}

input StudentRelateToManyForUpdateInput {
  disconnect: [StudentWhereUniqueInput!]
  set: [StudentWhereUniqueInput!]
  create: [StudentCreateInput!]
  connect: [StudentWhereUniqueInput!]
}

input BillRelateToManyForUpdateInput {
  disconnect: [BillWhereUniqueInput!]
  set: [BillWhereUniqueInput!]
  create: [BillCreateInput!]
  connect: [BillWhereUniqueInput!]
}

input AccountUpdateArgs {
  where: AccountWhereUniqueInput!
  data: AccountUpdateInput!
}

input AccountCreateInput {
  user: UserRelateToOneForCreateInput
  firstName: String
  surname: String
  phone: String
  secondContactName: String
  secondContactPhone: String
  students: StudentRelateToManyForCreateInput
  bills: BillRelateToManyForCreateInput
  streetAddress: String
  suburb: String
  postcode: Int
  xeroId: String
  createdAt: DateTime
}

input UserRelateToOneForCreateInput {
  create: UserCreateInput
  connect: UserWhereUniqueInput
}

input StudentRelateToManyForCreateInput {
  create: [StudentCreateInput!]
  connect: [StudentWhereUniqueInput!]
}

input BillRelateToManyForCreateInput {
  create: [BillCreateInput!]
  connect: [BillWhereUniqueInput!]
}

type Student {
  id: ID!
  name: String
  firstName: String
  surname: String
  dateOfBirth: CalendarDay
  school: String
  yearLevel: Int
  medical: String
  account: Account
  enrolments(where: EnrolmentWhereInput! = {}, orderBy: [EnrolmentOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: EnrolmentWhereUniqueInput): [Enrolment!]
  enrolmentsCount(where: EnrolmentWhereInput! = {}): Int
  createdAt: DateTime
}

scalar CalendarDay @specifiedBy(url: "https://datatracker.ietf.org/doc/html/rfc3339#section-5.6")

input StudentWhereUniqueInput {
  id: ID
}

input StudentWhereInput {
  AND: [StudentWhereInput!]
  OR: [StudentWhereInput!]
  NOT: [StudentWhereInput!]
  id: IDFilter
  firstName: StringFilter
  surname: StringFilter
  dateOfBirth: CalendarDayFilter
  school: StringFilter
  yearLevel: IntFilter
  medical: StringNullableFilter
  account: AccountWhereInput
  enrolments: EnrolmentManyRelationFilter
  createdAt: DateTimeNullableFilter
}

input CalendarDayFilter {
  equals: CalendarDay
  in: [CalendarDay!]
  notIn: [CalendarDay!]
  lt: CalendarDay
  lte: CalendarDay
  gt: CalendarDay
  gte: CalendarDay
  not: CalendarDayFilter
}

input EnrolmentManyRelationFilter {
  every: EnrolmentWhereInput
  some: EnrolmentWhereInput
  none: EnrolmentWhereInput
}

input StudentOrderByInput {
  id: OrderDirection
  firstName: OrderDirection
  surname: OrderDirection
  dateOfBirth: OrderDirection
  school: OrderDirection
  yearLevel: OrderDirection
  medical: OrderDirection
  createdAt: OrderDirection
}

input StudentUpdateInput {
  firstName: String
  surname: String
  dateOfBirth: CalendarDay
  school: String
  yearLevel: Int
  medical: String
  account: AccountRelateToOneForUpdateInput
  enrolments: EnrolmentRelateToManyForUpdateInput
  createdAt: DateTime
}

input EnrolmentRelateToManyForUpdateInput {
  disconnect: [EnrolmentWhereUniqueInput!]
  set: [EnrolmentWhereUniqueInput!]
  create: [EnrolmentCreateInput!]
  connect: [EnrolmentWhereUniqueInput!]
}

input StudentUpdateArgs {
  where: StudentWhereUniqueInput!
  data: StudentUpdateInput!
}

input StudentCreateInput {
  firstName: String
  surname: String
  dateOfBirth: CalendarDay
  school: String
  yearLevel: Int
  medical: String
  account: AccountRelateToOneForCreateInput
  enrolments: EnrolmentRelateToManyForCreateInput
  createdAt: DateTime
}

input EnrolmentRelateToManyForCreateInput {
  create: [EnrolmentCreateInput!]
  connect: [EnrolmentWhereUniqueInput!]
}

type LessonCategory {
  id: ID!
  name: String
  slug: String
  cost: String
  type: String
  length: String
  description: String
  xeroAccountCode: String
  lessons(where: LessonWhereInput! = {}, orderBy: [LessonOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonWhereUniqueInput): [Lesson!]
  lessonsCount(where: LessonWhereInput! = {}): Int
}

input LessonCategoryWhereUniqueInput {
  id: ID
  slug: String
  xeroAccountCode: String
}

input LessonCategoryWhereInput {
  AND: [LessonCategoryWhereInput!]
  OR: [LessonCategoryWhereInput!]
  NOT: [LessonCategoryWhereInput!]
  id: IDFilter
  name: StringFilter
  slug: StringFilter
  cost: StringFilter
  type: StringFilter
  length: StringFilter
  description: StringNullableFilter
  xeroAccountCode: StringNullableFilter
  lessons: LessonManyRelationFilter
}

input LessonManyRelationFilter {
  every: LessonWhereInput
  some: LessonWhereInput
  none: LessonWhereInput
}

input LessonCategoryOrderByInput {
  id: OrderDirection
  name: OrderDirection
  slug: OrderDirection
  cost: OrderDirection
  type: OrderDirection
  length: OrderDirection
  description: OrderDirection
  xeroAccountCode: OrderDirection
}

input LessonCategoryUpdateInput {
  name: String
  slug: String
  cost: String
  type: String
  length: String
  description: String
  xeroAccountCode: String
  lessons: LessonRelateToManyForUpdateInput
}

input LessonRelateToManyForUpdateInput {
  disconnect: [LessonWhereUniqueInput!]
  set: [LessonWhereUniqueInput!]
  create: [LessonCreateInput!]
  connect: [LessonWhereUniqueInput!]
}

input LessonCategoryUpdateArgs {
  where: LessonCategoryWhereUniqueInput!
  data: LessonCategoryUpdateInput!
}

input LessonCategoryCreateInput {
  name: String
  slug: String
  cost: String
  type: String
  length: String
  description: String
  xeroAccountCode: String
  lessons: LessonRelateToManyForCreateInput
}

input LessonRelateToManyForCreateInput {
  create: [LessonCreateInput!]
  connect: [LessonWhereUniqueInput!]
}

type ImportantDate {
  id: ID!
  name: String
  date: CalendarDay
  brief: String
  description: String
}

input ImportantDateWhereUniqueInput {
  id: ID
}

input ImportantDateWhereInput {
  AND: [ImportantDateWhereInput!]
  OR: [ImportantDateWhereInput!]
  NOT: [ImportantDateWhereInput!]
  id: IDFilter
  name: StringFilter
  date: CalendarDayFilter
  brief: StringFilter
  description: StringNullableFilter
}

input ImportantDateOrderByInput {
  id: OrderDirection
  name: OrderDirection
  date: OrderDirection
  brief: OrderDirection
  description: OrderDirection
}

input ImportantDateUpdateInput {
  name: String
  date: CalendarDay
  brief: String
  description: String
}

input ImportantDateUpdateArgs {
  where: ImportantDateWhereUniqueInput!
  data: ImportantDateUpdateInput!
}

input ImportantDateCreateInput {
  name: String
  date: CalendarDay
  brief: String
  description: String
}

type Term {
  id: ID!
  name: String
  quantity: Int
  year: Int
  startDate: CalendarDay
  endDate: CalendarDay
  lessonTerms(where: LessonTermWhereInput! = {}, orderBy: [LessonTermOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonTermWhereUniqueInput): [LessonTerm!]
  lessonTermsCount(where: LessonTermWhereInput! = {}): Int
  termStatus: String
  copyFrom: Term
}

input TermWhereUniqueInput {
  id: ID
}

input TermWhereInput {
  AND: [TermWhereInput!]
  OR: [TermWhereInput!]
  NOT: [TermWhereInput!]
  id: IDFilter
  name: StringFilter
  quantity: IntFilter
  year: IntFilter
  startDate: CalendarDayFilter
  endDate: CalendarDayFilter
  lessonTerms: LessonTermManyRelationFilter
  termStatus: StringNullableFilter
  copyFrom: TermWhereInput
}

input LessonTermManyRelationFilter {
  every: LessonTermWhereInput
  some: LessonTermWhereInput
  none: LessonTermWhereInput
}

input TermOrderByInput {
  id: OrderDirection
  name: OrderDirection
  quantity: OrderDirection
  year: OrderDirection
  startDate: OrderDirection
  endDate: OrderDirection
  termStatus: OrderDirection
}

input TermUpdateInput {
  name: String
  quantity: Int
  year: Int
  startDate: CalendarDay
  endDate: CalendarDay
  lessonTerms: LessonTermRelateToManyForUpdateInput
  termStatus: String
  copyFrom: TermRelateToOneForUpdateInput
}

input LessonTermRelateToManyForUpdateInput {
  disconnect: [LessonTermWhereUniqueInput!]
  set: [LessonTermWhereUniqueInput!]
  create: [LessonTermCreateInput!]
  connect: [LessonTermWhereUniqueInput!]
}

input TermRelateToOneForUpdateInput {
  create: TermCreateInput
  connect: TermWhereUniqueInput
  disconnect: Boolean
}

input TermUpdateArgs {
  where: TermWhereUniqueInput!
  data: TermUpdateInput!
}

input TermCreateInput {
  name: String
  quantity: Int
  year: Int
  startDate: CalendarDay
  endDate: CalendarDay
  lessonTerms: LessonTermRelateToManyForCreateInput
  termStatus: String
  copyFrom: TermRelateToOneForCreateInput
}

input LessonTermRelateToManyForCreateInput {
  create: [LessonTermCreateInput!]
  connect: [LessonTermWhereUniqueInput!]
}

input TermRelateToOneForCreateInput {
  create: TermCreateInput
  connect: TermWhereUniqueInput
}

type LessonTerm {
  id: ID!
  name: String
  status: String
  term: Term
  lesson: Lesson
  enrolments(where: EnrolmentWhereInput! = {}, orderBy: [EnrolmentOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: EnrolmentWhereUniqueInput): [Enrolment!]
  enrolmentsCount(where: EnrolmentWhereInput! = {}): Int
  messages(where: MessageWhereInput! = {}, orderBy: [MessageOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: MessageWhereUniqueInput): [Message!]
  messagesCount(where: MessageWhereInput! = {}): Int
  numberOfLessons: Int
  createdAt: DateTime
}

input LessonTermWhereUniqueInput {
  id: ID
}

input LessonTermWhereInput {
  AND: [LessonTermWhereInput!]
  OR: [LessonTermWhereInput!]
  NOT: [LessonTermWhereInput!]
  id: IDFilter
  status: StringFilter
  term: TermWhereInput
  lesson: LessonWhereInput
  enrolments: EnrolmentManyRelationFilter
  messages: MessageManyRelationFilter
  numberOfLessons: IntFilter
  createdAt: DateTimeNullableFilter
}

input MessageManyRelationFilter {
  every: MessageWhereInput
  some: MessageWhereInput
  none: MessageWhereInput
}

input LessonTermOrderByInput {
  id: OrderDirection
  status: OrderDirection
  numberOfLessons: OrderDirection
  createdAt: OrderDirection
}

input LessonTermUpdateInput {
  status: String
  term: TermRelateToOneForUpdateInput
  lesson: LessonRelateToOneForUpdateInput
  enrolments: EnrolmentRelateToManyForUpdateInput
  messages: MessageRelateToManyForUpdateInput
  numberOfLessons: Int
  createdAt: DateTime
}

input LessonRelateToOneForUpdateInput {
  create: LessonCreateInput
  connect: LessonWhereUniqueInput
  disconnect: Boolean
}

input MessageRelateToManyForUpdateInput {
  disconnect: [MessageWhereUniqueInput!]
  set: [MessageWhereUniqueInput!]
  create: [MessageCreateInput!]
  connect: [MessageWhereUniqueInput!]
}

input LessonTermUpdateArgs {
  where: LessonTermWhereUniqueInput!
  data: LessonTermUpdateInput!
}

input LessonTermCreateInput {
  status: String
  term: TermRelateToOneForCreateInput
  lesson: LessonRelateToOneForCreateInput
  enrolments: EnrolmentRelateToManyForCreateInput
  messages: MessageRelateToManyForCreateInput
  numberOfLessons: Int
  createdAt: DateTime
}

input LessonRelateToOneForCreateInput {
  create: LessonCreateInput
  connect: LessonWhereUniqueInput
}

input MessageRelateToManyForCreateInput {
  create: [MessageCreateInput!]
  connect: [MessageWhereUniqueInput!]
}

type Lesson {
  id: ID!
  name: String
  lessonCategory: LessonCategory
  description: String
  cost: Int
  time: String
  lengthMin: Int
  day: String
  minYear: Int
  maxYear: Int
  location: String
  createdAt: DateTime
  lessonTerms(where: LessonTermWhereInput! = {}, orderBy: [LessonTermOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonTermWhereUniqueInput): [LessonTerm!]
  lessonTermsCount(where: LessonTermWhereInput! = {}): Int
  teachers(where: TeacherWhereInput! = {}, orderBy: [TeacherOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: TeacherWhereUniqueInput): [Teacher!]
  teachersCount(where: TeacherWhereInput! = {}): Int
}

input LessonWhereUniqueInput {
  id: ID
}

input LessonWhereInput {
  AND: [LessonWhereInput!]
  OR: [LessonWhereInput!]
  NOT: [LessonWhereInput!]
  id: IDFilter
  name: StringFilter
  lessonCategory: LessonCategoryWhereInput
  description: StringNullableFilter
  cost: IntFilter
  time: StringFilter
  lengthMin: IntFilter
  day: StringFilter
  minYear: IntFilter
  maxYear: IntFilter
  location: StringFilter
  createdAt: DateTimeNullableFilter
  lessonTerms: LessonTermManyRelationFilter
  teachers: TeacherManyRelationFilter
}

input TeacherManyRelationFilter {
  every: TeacherWhereInput
  some: TeacherWhereInput
  none: TeacherWhereInput
}

input LessonOrderByInput {
  id: OrderDirection
  name: OrderDirection
  description: OrderDirection
  cost: OrderDirection
  time: OrderDirection
  lengthMin: OrderDirection
  day: OrderDirection
  minYear: OrderDirection
  maxYear: OrderDirection
  location: OrderDirection
  createdAt: OrderDirection
}

input LessonUpdateInput {
  name: String
  lessonCategory: LessonCategoryRelateToOneForUpdateInput
  description: String
  cost: Int
  time: String
  lengthMin: Int
  day: String
  minYear: Int
  maxYear: Int
  location: String
  createdAt: DateTime
  lessonTerms: LessonTermRelateToManyForUpdateInput
  teachers: TeacherRelateToManyForUpdateInput
}

input LessonCategoryRelateToOneForUpdateInput {
  create: LessonCategoryCreateInput
  connect: LessonCategoryWhereUniqueInput
  disconnect: Boolean
}

input TeacherRelateToManyForUpdateInput {
  disconnect: [TeacherWhereUniqueInput!]
  set: [TeacherWhereUniqueInput!]
  create: [TeacherCreateInput!]
  connect: [TeacherWhereUniqueInput!]
}

input LessonUpdateArgs {
  where: LessonWhereUniqueInput!
  data: LessonUpdateInput!
}

input LessonCreateInput {
  name: String
  lessonCategory: LessonCategoryRelateToOneForCreateInput
  description: String
  cost: Int
  time: String
  lengthMin: Int
  day: String
  minYear: Int
  maxYear: Int
  location: String
  createdAt: DateTime
  lessonTerms: LessonTermRelateToManyForCreateInput
  teachers: TeacherRelateToManyForCreateInput
}

input LessonCategoryRelateToOneForCreateInput {
  create: LessonCategoryCreateInput
  connect: LessonCategoryWhereUniqueInput
}

input TeacherRelateToManyForCreateInput {
  create: [TeacherCreateInput!]
  connect: [TeacherWhereUniqueInput!]
}

type EmailSettings {
  id: ID!
  fromEmail: String
  enrolmentConfirmationTemplate: String
  lessonTermMessageTemplate: String
}

input EmailSettingsWhereUniqueInput {
  id: ID
}

input EmailSettingsWhereInput {
  AND: [EmailSettingsWhereInput!]
  OR: [EmailSettingsWhereInput!]
  NOT: [EmailSettingsWhereInput!]
  id: IDFilter
  fromEmail: StringFilter
  enrolmentConfirmationTemplate: StringFilter
  lessonTermMessageTemplate: StringFilter
}

input EmailSettingsOrderByInput {
  id: OrderDirection
  fromEmail: OrderDirection
  enrolmentConfirmationTemplate: OrderDirection
  lessonTermMessageTemplate: OrderDirection
}

input EmailSettingsUpdateInput {
  fromEmail: String
  enrolmentConfirmationTemplate: String
  lessonTermMessageTemplate: String
}

input EmailSettingsUpdateArgs {
  where: EmailSettingsWhereUniqueInput! = {id: 1}
  data: EmailSettingsUpdateInput!
}

input EmailSettingsCreateInput {
  fromEmail: String
  enrolmentConfirmationTemplate: String
  lessonTermMessageTemplate: String
}

type XeroSettings {
  id: ID!
  tokenSet: JSON
  tenantId: String
}

input XeroSettingsWhereUniqueInput {
  id: ID
}

input XeroSettingsWhereInput {
  AND: [XeroSettingsWhereInput!]
  OR: [XeroSettingsWhereInput!]
  NOT: [XeroSettingsWhereInput!]
  id: IDFilter
  tenantId: StringFilter
}

input XeroSettingsOrderByInput {
  id: OrderDirection
  tenantId: OrderDirection
}

input XeroSettingsUpdateInput {
  tokenSet: JSON
  tenantId: String
}

input XeroSettingsUpdateArgs {
  where: XeroSettingsWhereUniqueInput! = {id: 1}
  data: XeroSettingsUpdateInput!
}

input XeroSettingsCreateInput {
  tokenSet: JSON
  tenantId: String
}

type Teacher {
  id: ID!
  name: String
  bio: String
  position: String
  image: ImageFieldOutput
  lessons(where: LessonWhereInput! = {}, orderBy: [LessonOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonWhereUniqueInput): [Lesson!]
  lessonsCount(where: LessonWhereInput! = {}): Int
}

type ImageFieldOutput {
  id: ID!
  filesize: Int!
  width: Int!
  height: Int!
  extension: String!
  url: String!
}

input TeacherWhereUniqueInput {
  id: ID
}

input TeacherWhereInput {
  AND: [TeacherWhereInput!]
  OR: [TeacherWhereInput!]
  NOT: [TeacherWhereInput!]
  id: IDFilter
  name: StringFilter
  bio: StringNullableFilter
  position: StringFilter
  lessons: LessonManyRelationFilter
}

input TeacherOrderByInput {
  id: OrderDirection
  name: OrderDirection
  bio: OrderDirection
  position: OrderDirection
}

input TeacherUpdateInput {
  name: String
  bio: String
  position: String
  image: ImageFieldInput
  lessons: LessonRelateToManyForUpdateInput
}

input ImageFieldInput {
  upload: File!
}

"""The `Upload` scalar type represents a file upload."""
scalar File

input TeacherUpdateArgs {
  where: TeacherWhereUniqueInput!
  data: TeacherUpdateInput!
}

input TeacherCreateInput {
  name: String
  bio: String
  position: String
  image: ImageFieldInput
  lessons: LessonRelateToManyForCreateInput
}

type Enrolment {
  id: ID!
  lessonTerm: LessonTerm
  student: Student
  status: String
  billItem: BillItem
  createdAt: DateTime
}

input EnrolmentWhereUniqueInput {
  id: ID
}

input EnrolmentWhereInput {
  AND: [EnrolmentWhereInput!]
  OR: [EnrolmentWhereInput!]
  NOT: [EnrolmentWhereInput!]
  id: IDFilter
  lessonTerm: LessonTermWhereInput
  student: StudentWhereInput
  status: StringFilter
  billItem: BillItemWhereInput
  createdAt: DateTimeNullableFilter
}

input EnrolmentOrderByInput {
  id: OrderDirection
  status: OrderDirection
  createdAt: OrderDirection
}

input EnrolmentUpdateInput {
  lessonTerm: LessonTermRelateToOneForUpdateInput
  student: StudentRelateToOneForUpdateInput
  status: String
  billItem: BillItemRelateToOneForUpdateInput
  createdAt: DateTime
}

input LessonTermRelateToOneForUpdateInput {
  create: LessonTermCreateInput
  connect: LessonTermWhereUniqueInput
  disconnect: Boolean
}

input StudentRelateToOneForUpdateInput {
  create: StudentCreateInput
  connect: StudentWhereUniqueInput
  disconnect: Boolean
}

input BillItemRelateToOneForUpdateInput {
  create: BillItemCreateInput
  connect: BillItemWhereUniqueInput
  disconnect: Boolean
}

input EnrolmentUpdateArgs {
  where: EnrolmentWhereUniqueInput!
  data: EnrolmentUpdateInput!
}

input EnrolmentCreateInput {
  lessonTerm: LessonTermRelateToOneForCreateInput
  student: StudentRelateToOneForCreateInput
  status: String
  billItem: BillItemRelateToOneForCreateInput
  createdAt: DateTime
}

input LessonTermRelateToOneForCreateInput {
  create: LessonTermCreateInput
  connect: LessonTermWhereUniqueInput
}

input StudentRelateToOneForCreateInput {
  create: StudentCreateInput
  connect: StudentWhereUniqueInput
}

input BillItemRelateToOneForCreateInput {
  create: BillItemCreateInput
  connect: BillItemWhereUniqueInput
}

type Message {
  id: ID!
  name: String
  status: String
  content: String
  lessonTerms(where: LessonTermWhereInput! = {}, orderBy: [LessonTermOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonTermWhereUniqueInput): [LessonTerm!]
  lessonTermsCount(where: LessonTermWhereInput! = {}): Int
  sentAt: DateTime
  createdAt: DateTime
}

input MessageWhereUniqueInput {
  id: ID
}

input MessageWhereInput {
  AND: [MessageWhereInput!]
  OR: [MessageWhereInput!]
  NOT: [MessageWhereInput!]
  id: IDFilter
  name: StringFilter
  status: StringFilter
  content: StringNullableFilter
  lessonTerms: LessonTermManyRelationFilter
  sentAt: DateTimeNullableFilter
  createdAt: DateTimeNullableFilter
}

input MessageOrderByInput {
  id: OrderDirection
  name: OrderDirection
  status: OrderDirection
  content: OrderDirection
  sentAt: OrderDirection
  createdAt: OrderDirection
}

input MessageUpdateInput {
  name: String
  status: String
  content: String
  lessonTerms: LessonTermRelateToManyForUpdateInput
  sentAt: DateTime
  createdAt: DateTime
}

input MessageUpdateArgs {
  where: MessageWhereUniqueInput!
  data: MessageUpdateInput!
}

input MessageCreateInput {
  name: String
  status: String
  content: String
  lessonTerms: LessonTermRelateToManyForCreateInput
  sentAt: DateTime
  createdAt: DateTime
}

type Bill {
  id: ID!
  name: String
  account: Account
  date: CalendarDay
  dueDate: CalendarDay
  total: Decimal
  status: String
  term: Term
  items(where: BillItemWhereInput! = {}, orderBy: [BillItemOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: BillItemWhereUniqueInput): [BillItem!]
  itemsCount(where: BillItemWhereInput! = {}): Int
  xeroId: String
  createdAt: DateTime
}

scalar Decimal

input BillWhereUniqueInput {
  id: ID
  xeroId: String
}

input BillWhereInput {
  AND: [BillWhereInput!]
  OR: [BillWhereInput!]
  NOT: [BillWhereInput!]
  id: IDFilter
  name: StringFilter
  account: AccountWhereInput
  date: CalendarDayNullableFilter
  dueDate: CalendarDayNullableFilter
  status: StringFilter
  term: TermWhereInput
  items: BillItemManyRelationFilter
  xeroId: StringNullableFilter
  createdAt: DateTimeNullableFilter
}

input CalendarDayNullableFilter {
  equals: CalendarDay
  in: [CalendarDay!]
  notIn: [CalendarDay!]
  lt: CalendarDay
  lte: CalendarDay
  gt: CalendarDay
  gte: CalendarDay
  not: CalendarDayNullableFilter
}

input BillItemManyRelationFilter {
  every: BillItemWhereInput
  some: BillItemWhereInput
  none: BillItemWhereInput
}

input BillOrderByInput {
  id: OrderDirection
  name: OrderDirection
  date: OrderDirection
  dueDate: OrderDirection
  status: OrderDirection
  xeroId: OrderDirection
  createdAt: OrderDirection
}

input BillUpdateInput {
  name: String
  account: AccountRelateToOneForUpdateInput
  date: CalendarDay
  dueDate: CalendarDay
  status: String
  term: TermRelateToOneForUpdateInput
  items: BillItemRelateToManyForUpdateInput
  xeroId: String
  createdAt: DateTime
}

input BillItemRelateToManyForUpdateInput {
  disconnect: [BillItemWhereUniqueInput!]
  set: [BillItemWhereUniqueInput!]
  create: [BillItemCreateInput!]
  connect: [BillItemWhereUniqueInput!]
}

input BillUpdateArgs {
  where: BillWhereUniqueInput!
  data: BillUpdateInput!
}

input BillCreateInput {
  name: String
  account: AccountRelateToOneForCreateInput
  date: CalendarDay
  dueDate: CalendarDay
  status: String
  term: TermRelateToOneForCreateInput
  items: BillItemRelateToManyForCreateInput
  xeroId: String
  createdAt: DateTime
}

input BillItemRelateToManyForCreateInput {
  create: [BillItemCreateInput!]
  connect: [BillItemWhereUniqueInput!]
}

type BillItem {
  id: ID!
  name: String
  bill: Bill
  quantity: Int
  amount: Int
  total: Decimal!
  enrolment: Enrolment
  xeroId: String
  createdAt: DateTime
}

input BillItemWhereUniqueInput {
  id: ID
  xeroId: String
}

input BillItemWhereInput {
  AND: [BillItemWhereInput!]
  OR: [BillItemWhereInput!]
  NOT: [BillItemWhereInput!]
  id: IDFilter
  name: StringFilter
  bill: BillWhereInput
  quantity: IntFilter
  amount: IntFilter
  enrolment: EnrolmentWhereInput
  xeroId: StringNullableFilter
  createdAt: DateTimeNullableFilter
}

input BillItemOrderByInput {
  id: OrderDirection
  name: OrderDirection
  quantity: OrderDirection
  amount: OrderDirection
  xeroId: OrderDirection
  createdAt: OrderDirection
}

input BillItemUpdateInput {
  name: String
  bill: BillRelateToOneForUpdateInput
  quantity: Int
  amount: Int
  enrolment: EnrolmentRelateToOneForUpdateInput
  xeroId: String
  createdAt: DateTime
}

input BillRelateToOneForUpdateInput {
  create: BillCreateInput
  connect: BillWhereUniqueInput
  disconnect: Boolean
}

input EnrolmentRelateToOneForUpdateInput {
  create: EnrolmentCreateInput
  connect: EnrolmentWhereUniqueInput
  disconnect: Boolean
}

input BillItemUpdateArgs {
  where: BillItemWhereUniqueInput!
  data: BillItemUpdateInput!
}

input BillItemCreateInput {
  name: String
  bill: BillRelateToOneForCreateInput
  quantity: Int
  amount: Int
  enrolment: EnrolmentRelateToOneForCreateInput
  xeroId: String
  createdAt: DateTime
}

input BillRelateToOneForCreateInput {
  create: BillCreateInput
  connect: BillWhereUniqueInput
}

input EnrolmentRelateToOneForCreateInput {
  create: EnrolmentCreateInput
  connect: EnrolmentWhereUniqueInput
}

"""
The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
"""
scalar JSON @specifiedBy(url: "http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf")

type Mutation {
  createUser(data: UserCreateInput!): User
  createUsers(data: [UserCreateInput!]!): [User]
  updateUser(where: UserWhereUniqueInput!, data: UserUpdateInput!): User
  updateUsers(data: [UserUpdateArgs!]!): [User]
  deleteUser(where: UserWhereUniqueInput!): User
  deleteUsers(where: [UserWhereUniqueInput!]!): [User]
  createAccount(data: AccountCreateInput!): Account
  createAccounts(data: [AccountCreateInput!]!): [Account]
  updateAccount(where: AccountWhereUniqueInput!, data: AccountUpdateInput!): Account
  updateAccounts(data: [AccountUpdateArgs!]!): [Account]
  deleteAccount(where: AccountWhereUniqueInput!): Account
  deleteAccounts(where: [AccountWhereUniqueInput!]!): [Account]
  createStudent(data: StudentCreateInput!): Student
  createStudents(data: [StudentCreateInput!]!): [Student]
  updateStudent(where: StudentWhereUniqueInput!, data: StudentUpdateInput!): Student
  updateStudents(data: [StudentUpdateArgs!]!): [Student]
  deleteStudent(where: StudentWhereUniqueInput!): Student
  deleteStudents(where: [StudentWhereUniqueInput!]!): [Student]
  createLessonCategory(data: LessonCategoryCreateInput!): LessonCategory
  createLessonCategories(data: [LessonCategoryCreateInput!]!): [LessonCategory]
  updateLessonCategory(where: LessonCategoryWhereUniqueInput!, data: LessonCategoryUpdateInput!): LessonCategory
  updateLessonCategories(data: [LessonCategoryUpdateArgs!]!): [LessonCategory]
  deleteLessonCategory(where: LessonCategoryWhereUniqueInput!): LessonCategory
  deleteLessonCategories(where: [LessonCategoryWhereUniqueInput!]!): [LessonCategory]
  createImportantDate(data: ImportantDateCreateInput!): ImportantDate
  createImportantDates(data: [ImportantDateCreateInput!]!): [ImportantDate]
  updateImportantDate(where: ImportantDateWhereUniqueInput!, data: ImportantDateUpdateInput!): ImportantDate
  updateImportantDates(data: [ImportantDateUpdateArgs!]!): [ImportantDate]
  deleteImportantDate(where: ImportantDateWhereUniqueInput!): ImportantDate
  deleteImportantDates(where: [ImportantDateWhereUniqueInput!]!): [ImportantDate]
  createTerm(data: TermCreateInput!): Term
  createTerms(data: [TermCreateInput!]!): [Term]
  updateTerm(where: TermWhereUniqueInput!, data: TermUpdateInput!): Term
  updateTerms(data: [TermUpdateArgs!]!): [Term]
  deleteTerm(where: TermWhereUniqueInput!): Term
  deleteTerms(where: [TermWhereUniqueInput!]!): [Term]
  createLessonTerm(data: LessonTermCreateInput!): LessonTerm
  createLessonTerms(data: [LessonTermCreateInput!]!): [LessonTerm]
  updateLessonTerm(where: LessonTermWhereUniqueInput!, data: LessonTermUpdateInput!): LessonTerm
  updateLessonTerms(data: [LessonTermUpdateArgs!]!): [LessonTerm]
  deleteLessonTerm(where: LessonTermWhereUniqueInput!): LessonTerm
  deleteLessonTerms(where: [LessonTermWhereUniqueInput!]!): [LessonTerm]
  createLesson(data: LessonCreateInput!): Lesson
  createLessons(data: [LessonCreateInput!]!): [Lesson]
  updateLesson(where: LessonWhereUniqueInput!, data: LessonUpdateInput!): Lesson
  updateLessons(data: [LessonUpdateArgs!]!): [Lesson]
  deleteLesson(where: LessonWhereUniqueInput!): Lesson
  deleteLessons(where: [LessonWhereUniqueInput!]!): [Lesson]
  createEmailSettings(data: EmailSettingsCreateInput!): EmailSettings
  createManyEmailSettings(data: [EmailSettingsCreateInput!]!): [EmailSettings]
  updateEmailSettings(where: EmailSettingsWhereUniqueInput! = {id: 1}, data: EmailSettingsUpdateInput!): EmailSettings
  updateManyEmailSettings(data: [EmailSettingsUpdateArgs!]!): [EmailSettings]
  deleteEmailSettings(where: EmailSettingsWhereUniqueInput! = {id: 1}): EmailSettings
  deleteManyEmailSettings(where: [EmailSettingsWhereUniqueInput!]!): [EmailSettings]
  createXeroSettings(data: XeroSettingsCreateInput!): XeroSettings
  createManyXeroSettings(data: [XeroSettingsCreateInput!]!): [XeroSettings]
  updateXeroSettings(where: XeroSettingsWhereUniqueInput! = {id: 1}, data: XeroSettingsUpdateInput!): XeroSettings
  updateManyXeroSettings(data: [XeroSettingsUpdateArgs!]!): [XeroSettings]
  deleteXeroSettings(where: XeroSettingsWhereUniqueInput! = {id: 1}): XeroSettings
  deleteManyXeroSettings(where: [XeroSettingsWhereUniqueInput!]!): [XeroSettings]
  createTeacher(data: TeacherCreateInput!): Teacher
  createTeachers(data: [TeacherCreateInput!]!): [Teacher]
  updateTeacher(where: TeacherWhereUniqueInput!, data: TeacherUpdateInput!): Teacher
  updateTeachers(data: [TeacherUpdateArgs!]!): [Teacher]
  deleteTeacher(where: TeacherWhereUniqueInput!): Teacher
  deleteTeachers(where: [TeacherWhereUniqueInput!]!): [Teacher]
  createEnrolment(data: EnrolmentCreateInput!): Enrolment
  createEnrolments(data: [EnrolmentCreateInput!]!): [Enrolment]
  updateEnrolment(where: EnrolmentWhereUniqueInput!, data: EnrolmentUpdateInput!): Enrolment
  updateEnrolments(data: [EnrolmentUpdateArgs!]!): [Enrolment]
  deleteEnrolment(where: EnrolmentWhereUniqueInput!): Enrolment
  deleteEnrolments(where: [EnrolmentWhereUniqueInput!]!): [Enrolment]
  createMessage(data: MessageCreateInput!): Message
  createMessages(data: [MessageCreateInput!]!): [Message]
  updateMessage(where: MessageWhereUniqueInput!, data: MessageUpdateInput!): Message
  updateMessages(data: [MessageUpdateArgs!]!): [Message]
  deleteMessage(where: MessageWhereUniqueInput!): Message
  deleteMessages(where: [MessageWhereUniqueInput!]!): [Message]
  createBill(data: BillCreateInput!): Bill
  createBills(data: [BillCreateInput!]!): [Bill]
  updateBill(where: BillWhereUniqueInput!, data: BillUpdateInput!): Bill
  updateBills(data: [BillUpdateArgs!]!): [Bill]
  deleteBill(where: BillWhereUniqueInput!): Bill
  deleteBills(where: [BillWhereUniqueInput!]!): [Bill]
  createBillItem(data: BillItemCreateInput!): BillItem
  createBillItems(data: [BillItemCreateInput!]!): [BillItem]
  updateBillItem(where: BillItemWhereUniqueInput!, data: BillItemUpdateInput!): BillItem
  updateBillItems(data: [BillItemUpdateArgs!]!): [BillItem]
  deleteBillItem(where: BillItemWhereUniqueInput!): BillItem
  deleteBillItems(where: [BillItemWhereUniqueInput!]!): [BillItem]
}

type Query {
  users(where: UserWhereInput! = {}, orderBy: [UserOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: UserWhereUniqueInput): [User!]
  user(where: UserWhereUniqueInput!): User
  usersCount(where: UserWhereInput! = {}): Int
  accounts(where: AccountWhereInput! = {}, orderBy: [AccountOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: AccountWhereUniqueInput): [Account!]
  account(where: AccountWhereUniqueInput!): Account
  accountsCount(where: AccountWhereInput! = {}): Int
  students(where: StudentWhereInput! = {}, orderBy: [StudentOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: StudentWhereUniqueInput): [Student!]
  student(where: StudentWhereUniqueInput!): Student
  studentsCount(where: StudentWhereInput! = {}): Int
  lessonCategories(where: LessonCategoryWhereInput! = {}, orderBy: [LessonCategoryOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonCategoryWhereUniqueInput): [LessonCategory!]
  lessonCategory(where: LessonCategoryWhereUniqueInput!): LessonCategory
  lessonCategoriesCount(where: LessonCategoryWhereInput! = {}): Int
  importantDates(where: ImportantDateWhereInput! = {}, orderBy: [ImportantDateOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: ImportantDateWhereUniqueInput): [ImportantDate!]
  importantDate(where: ImportantDateWhereUniqueInput!): ImportantDate
  importantDatesCount(where: ImportantDateWhereInput! = {}): Int
  terms(where: TermWhereInput! = {}, orderBy: [TermOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: TermWhereUniqueInput): [Term!]
  term(where: TermWhereUniqueInput!): Term
  termsCount(where: TermWhereInput! = {}): Int
  lessonTerms(where: LessonTermWhereInput! = {}, orderBy: [LessonTermOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonTermWhereUniqueInput): [LessonTerm!]
  lessonTerm(where: LessonTermWhereUniqueInput!): LessonTerm
  lessonTermsCount(where: LessonTermWhereInput! = {}): Int
  lessons(where: LessonWhereInput! = {}, orderBy: [LessonOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: LessonWhereUniqueInput): [Lesson!]
  lesson(where: LessonWhereUniqueInput!): Lesson
  lessonsCount(where: LessonWhereInput! = {}): Int
  manyEmailSettings(where: EmailSettingsWhereInput! = {id: {equals: 1}}, orderBy: [EmailSettingsOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: EmailSettingsWhereUniqueInput): [EmailSettings!]
  emailSettings(where: EmailSettingsWhereUniqueInput! = {id: 1}): EmailSettings
  manyEmailSettingsCount(where: EmailSettingsWhereInput! = {id: {equals: 1}}): Int
  manyXeroSettings(where: XeroSettingsWhereInput! = {id: {equals: 1}}, orderBy: [XeroSettingsOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: XeroSettingsWhereUniqueInput): [XeroSettings!]
  xeroSettings(where: XeroSettingsWhereUniqueInput! = {id: 1}): XeroSettings
  manyXeroSettingsCount(where: XeroSettingsWhereInput! = {id: {equals: 1}}): Int
  teachers(where: TeacherWhereInput! = {}, orderBy: [TeacherOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: TeacherWhereUniqueInput): [Teacher!]
  teacher(where: TeacherWhereUniqueInput!): Teacher
  teachersCount(where: TeacherWhereInput! = {}): Int
  enrolments(where: EnrolmentWhereInput! = {}, orderBy: [EnrolmentOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: EnrolmentWhereUniqueInput): [Enrolment!]
  enrolment(where: EnrolmentWhereUniqueInput!): Enrolment
  enrolmentsCount(where: EnrolmentWhereInput! = {}): Int
  messages(where: MessageWhereInput! = {}, orderBy: [MessageOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: MessageWhereUniqueInput): [Message!]
  message(where: MessageWhereUniqueInput!): Message
  messagesCount(where: MessageWhereInput! = {}): Int
  bills(where: BillWhereInput! = {}, orderBy: [BillOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: BillWhereUniqueInput): [Bill!]
  bill(where: BillWhereUniqueInput!): Bill
  billsCount(where: BillWhereInput! = {}): Int
  billItems(where: BillItemWhereInput! = {}, orderBy: [BillItemOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: BillItemWhereUniqueInput): [BillItem!]
  billItem(where: BillItemWhereUniqueInput!): BillItem
  billItemsCount(where: BillItemWhereInput! = {}): Int
  keystone: KeystoneMeta!
}

type KeystoneMeta {
  adminMeta: KeystoneAdminMeta!
}

type KeystoneAdminMeta {
  lists: [KeystoneAdminUIListMeta!]!
  list(key: String!): KeystoneAdminUIListMeta
}

type KeystoneAdminUIListMeta {
  key: String!
  itemQueryName: String!
  listQueryName: String!
  hideCreate: Boolean!
  hideDelete: Boolean!
  path: String!
  label: String!
  singular: String!
  plural: String!
  description: String
  initialColumns: [String!]!
  pageSize: Int!
  labelField: String!
  fields: [KeystoneAdminUIFieldMeta!]!
  groups: [KeystoneAdminUIFieldGroupMeta!]!
  initialSort: KeystoneAdminUISort
  isHidden: Boolean!
  isSingleton: Boolean!
}

type KeystoneAdminUIFieldMeta {
  path: String!
  label: String!
  description: String
  isOrderable: Boolean!
  isFilterable: Boolean!
  isNonNull: [KeystoneAdminUIFieldMetaIsNonNull!]
  fieldMeta: JSON
  viewsIndex: Int!
  customViewsIndex: Int
  createView: KeystoneAdminUIFieldMetaCreateView!
  listView: KeystoneAdminUIFieldMetaListView!
  itemView(id: ID): KeystoneAdminUIFieldMetaItemView
  search: QueryMode
}

enum KeystoneAdminUIFieldMetaIsNonNull {
  read
  create
  update
}

type KeystoneAdminUIFieldMetaCreateView {
  fieldMode: KeystoneAdminUIFieldMetaCreateViewFieldMode!
}

enum KeystoneAdminUIFieldMetaCreateViewFieldMode {
  edit
  hidden
}

type KeystoneAdminUIFieldMetaListView {
  fieldMode: KeystoneAdminUIFieldMetaListViewFieldMode!
}

enum KeystoneAdminUIFieldMetaListViewFieldMode {
  read
  hidden
}

type KeystoneAdminUIFieldMetaItemView {
  fieldMode: KeystoneAdminUIFieldMetaItemViewFieldMode
  fieldPosition: KeystoneAdminUIFieldMetaItemViewFieldPosition
}

enum KeystoneAdminUIFieldMetaItemViewFieldMode {
  edit
  read
  hidden
}

enum KeystoneAdminUIFieldMetaItemViewFieldPosition {
  form
  sidebar
}

type KeystoneAdminUIFieldGroupMeta {
  label: String!
  description: String
  fields: [KeystoneAdminUIFieldMeta!]!
}

type KeystoneAdminUISort {
  field: String!
  direction: KeystoneAdminUISortDirection!
}

enum KeystoneAdminUISortDirection {
  ASC
  DESC
}