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
  password: PasswordState
  isAdmin: Boolean
  createdAt: DateTime
}

type PasswordState {
  isSet: Boolean!
}

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

input UserWhereUniqueInput {
  id: ID
  email: String
}

input UserWhereInput {
  AND: [UserWhereInput!]
  OR: [UserWhereInput!]
  NOT: [UserWhereInput!]
  id: IDFilter
  name: StringFilter
  email: StringFilter
  password: PasswordFilter
  isAdmin: BooleanFilter
  createdAt: DateTimeNullableFilter
}

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 PasswordFilter {
  isSet: Boolean!
}

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 UserOrderByInput {
  id: OrderDirection
  name: OrderDirection
  email: OrderDirection
  isAdmin: OrderDirection
  createdAt: OrderDirection
}

enum OrderDirection {
  asc
  desc
}

input UserUpdateInput {
  name: String
  email: String
  password: String
  isAdmin: Boolean
  createdAt: DateTime
}

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

input UserCreateInput {
  name: String
  email: String
  password: String
  isAdmin: Boolean
  createdAt: DateTime
}

type PushSubscription {
  id: ID!
  endpoint: String
  expirationTime: DateTime
  keys: JSON
  user: User
  createdAt: DateTime
  lastUsed: DateTime
  userAgent: String
  deviceType: String
  os: String
  browser: String
}

input PushSubscriptionWhereUniqueInput {
  id: ID
  endpoint: String
}

input PushSubscriptionWhereInput {
  AND: [PushSubscriptionWhereInput!]
  OR: [PushSubscriptionWhereInput!]
  NOT: [PushSubscriptionWhereInput!]
  id: IDFilter
  endpoint: StringFilter
  expirationTime: DateTimeNullableFilter
  user: UserWhereInput
  createdAt: DateTimeNullableFilter
  lastUsed: DateTimeNullableFilter
  userAgent: StringFilter
  deviceType: StringFilter
  os: StringFilter
  browser: StringFilter
}

input PushSubscriptionOrderByInput {
  id: OrderDirection
  endpoint: OrderDirection
  expirationTime: OrderDirection
  createdAt: OrderDirection
  lastUsed: OrderDirection
  userAgent: OrderDirection
  deviceType: OrderDirection
  os: OrderDirection
  browser: OrderDirection
}

input PushSubscriptionUpdateInput {
  endpoint: String
  expirationTime: DateTime
  keys: JSON
  user: UserRelateToOneForUpdateInput
  createdAt: DateTime
  lastUsed: DateTime
  userAgent: String
  deviceType: String
  os: String
  browser: String
}

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

input PushSubscriptionUpdateArgs {
  where: PushSubscriptionWhereUniqueInput!
  data: PushSubscriptionUpdateInput!
}

input PushSubscriptionCreateInput {
  endpoint: String
  expirationTime: DateTime
  keys: JSON
  user: UserRelateToOneForCreateInput
  createdAt: DateTime
  lastUsed: DateTime
  userAgent: String
  deviceType: String
  os: String
  browser: String
}

input UserRelateToOneForCreateInput {
  create: UserCreateInput
  connect: UserWhereUniqueInput
}

type Topik {
  id: ID!
  no: Int
  year: Int
  level: TopikLevelType
  parentId: Topik
  childrenId(where: TopikWhereInput! = {}, orderBy: [TopikOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: TopikWhereUniqueInput): [Topik!]
  childrenIdCount(where: TopikWhereInput! = {}): Int
  questionNumber: Int
  questionType: TopikQuestionTypeType
  score: Int
  audioURL: String
  questionStem: String
  questionContent: String
  options: JSON
  explanation: String
  createdAt: DateTime
}

enum TopikLevelType {
  TOPIK_I
  TOPIK_II
}

enum TopikQuestionTypeType {
  LISTENING
  READING
  WRITING
}

input TopikWhereUniqueInput {
  id: ID
}

input TopikWhereInput {
  AND: [TopikWhereInput!]
  OR: [TopikWhereInput!]
  NOT: [TopikWhereInput!]
  id: IDFilter
  no: IntFilter
  year: IntFilter
  level: TopikLevelTypeNullableFilter
  parentId: TopikWhereInput
  childrenId: TopikManyRelationFilter
  questionNumber: IntFilter
  questionType: TopikQuestionTypeTypeNullableFilter
  score: IntFilter
  audioURL: StringFilter
  questionStem: StringFilter
  questionContent: StringFilter
  explanation: StringFilter
  createdAt: DateTimeNullableFilter
}

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

input TopikLevelTypeNullableFilter {
  equals: TopikLevelType
  in: [TopikLevelType!]
  notIn: [TopikLevelType!]
  not: TopikLevelTypeNullableFilter
}

input TopikManyRelationFilter {
  every: TopikWhereInput
  some: TopikWhereInput
  none: TopikWhereInput
}

input TopikQuestionTypeTypeNullableFilter {
  equals: TopikQuestionTypeType
  in: [TopikQuestionTypeType!]
  notIn: [TopikQuestionTypeType!]
  not: TopikQuestionTypeTypeNullableFilter
}

input TopikOrderByInput {
  id: OrderDirection
  no: OrderDirection
  year: OrderDirection
  level: OrderDirection
  questionNumber: OrderDirection
  questionType: OrderDirection
  score: OrderDirection
  audioURL: OrderDirection
  questionStem: OrderDirection
  questionContent: OrderDirection
  explanation: OrderDirection
  createdAt: OrderDirection
}

input TopikUpdateInput {
  no: Int
  year: Int
  level: TopikLevelType
  parentId: TopikRelateToOneForUpdateInput
  childrenId: TopikRelateToManyForUpdateInput
  questionNumber: Int
  questionType: TopikQuestionTypeType
  score: Int
  audioURL: String
  questionStem: String
  questionContent: String
  options: JSON
  explanation: String
  createdAt: DateTime
}

input TopikRelateToOneForUpdateInput {
  create: TopikCreateInput
  connect: TopikWhereUniqueInput
  disconnect: Boolean
}

input TopikRelateToManyForUpdateInput {
  disconnect: [TopikWhereUniqueInput!]
  set: [TopikWhereUniqueInput!]
  create: [TopikCreateInput!]
  connect: [TopikWhereUniqueInput!]
}

input TopikUpdateArgs {
  where: TopikWhereUniqueInput!
  data: TopikUpdateInput!
}

input TopikCreateInput {
  no: Int
  year: Int
  level: TopikLevelType
  parentId: TopikRelateToOneForCreateInput
  childrenId: TopikRelateToManyForCreateInput
  questionNumber: Int
  questionType: TopikQuestionTypeType
  score: Int
  audioURL: String
  questionStem: String
  questionContent: String
  options: JSON
  explanation: String
  createdAt: DateTime
}

input TopikRelateToOneForCreateInput {
  create: TopikCreateInput
  connect: TopikWhereUniqueInput
}

input TopikRelateToManyForCreateInput {
  create: [TopikCreateInput!]
  connect: [TopikWhereUniqueInput!]
}

type Dict {
  id: ID!
  name: String
  public: Boolean
  intlKey: String
  createdAt: DateTime
  createdBy: User
  list(where: DictItemWhereInput! = {}, orderBy: [DictItemOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictItemWhereUniqueInput): [DictItem!]
  listCount(where: DictItemWhereInput! = {}): Int
  poster: String
  favorites(where: DictItemFavoriteWhereInput! = {}, orderBy: [DictItemFavoriteOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictItemFavoriteWhereUniqueInput): [DictItemFavorite!]
  favoritesCount(where: DictItemFavoriteWhereInput! = {}): Int
}

input DictWhereUniqueInput {
  id: ID
}

input DictWhereInput {
  AND: [DictWhereInput!]
  OR: [DictWhereInput!]
  NOT: [DictWhereInput!]
  id: IDFilter
  name: StringFilter
  public: BooleanFilter
  intlKey: StringFilter
  createdAt: DateTimeNullableFilter
  createdBy: UserWhereInput
  list: DictItemManyRelationFilter
  poster: StringFilter
  favorites: DictItemFavoriteManyRelationFilter
}

input DictItemManyRelationFilter {
  every: DictItemWhereInput
  some: DictItemWhereInput
  none: DictItemWhereInput
}

input DictItemFavoriteManyRelationFilter {
  every: DictItemFavoriteWhereInput
  some: DictItemFavoriteWhereInput
  none: DictItemFavoriteWhereInput
}

input DictOrderByInput {
  id: OrderDirection
  name: OrderDirection
  public: OrderDirection
  intlKey: OrderDirection
  createdAt: OrderDirection
  poster: OrderDirection
}

input DictUpdateInput {
  name: String
  public: Boolean
  intlKey: String
  createdAt: DateTime
  createdBy: UserRelateToOneForUpdateInput
  list: DictItemRelateToManyForUpdateInput
  poster: String
  favorites: DictItemFavoriteRelateToManyForUpdateInput
}

input DictItemRelateToManyForUpdateInput {
  disconnect: [DictItemWhereUniqueInput!]
  set: [DictItemWhereUniqueInput!]
  create: [DictItemCreateInput!]
  connect: [DictItemWhereUniqueInput!]
}

input DictItemFavoriteRelateToManyForUpdateInput {
  disconnect: [DictItemFavoriteWhereUniqueInput!]
  set: [DictItemFavoriteWhereUniqueInput!]
  create: [DictItemFavoriteCreateInput!]
  connect: [DictItemFavoriteWhereUniqueInput!]
}

input DictUpdateArgs {
  where: DictWhereUniqueInput!
  data: DictUpdateInput!
}

input DictCreateInput {
  name: String
  public: Boolean
  intlKey: String
  createdAt: DateTime
  createdBy: UserRelateToOneForCreateInput
  list: DictItemRelateToManyForCreateInput
  poster: String
  favorites: DictItemFavoriteRelateToManyForCreateInput
}

input DictItemRelateToManyForCreateInput {
  create: [DictItemCreateInput!]
  connect: [DictItemWhereUniqueInput!]
}

input DictItemFavoriteRelateToManyForCreateInput {
  create: [DictItemFavoriteCreateInput!]
  connect: [DictItemFavoriteWhereUniqueInput!]
}

type DictItem {
  id: ID!
  name: String
  trans: JSON
  example: String
  exTrans: JSON
  createdAt: DateTime
  createdBy: User
  dict(where: DictWhereInput! = {}, orderBy: [DictOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictWhereUniqueInput): [Dict!]
  dictCount(where: DictWhereInput! = {}): Int
  favoriteIn(where: DictItemFavoriteWhereInput! = {}, orderBy: [DictItemFavoriteOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictItemFavoriteWhereUniqueInput): [DictItemFavorite!]
  favoriteInCount(where: DictItemFavoriteWhereInput! = {}): Int
}

input DictItemWhereUniqueInput {
  id: ID
}

input DictItemWhereInput {
  AND: [DictItemWhereInput!]
  OR: [DictItemWhereInput!]
  NOT: [DictItemWhereInput!]
  id: IDFilter
  name: StringFilter
  example: StringFilter
  createdAt: DateTimeNullableFilter
  createdBy: UserWhereInput
  dict: DictManyRelationFilter
  favoriteIn: DictItemFavoriteManyRelationFilter
}

input DictManyRelationFilter {
  every: DictWhereInput
  some: DictWhereInput
  none: DictWhereInput
}

input DictItemOrderByInput {
  id: OrderDirection
  name: OrderDirection
  example: OrderDirection
  createdAt: OrderDirection
}

input DictItemUpdateInput {
  name: String
  trans: JSON
  example: String
  exTrans: JSON
  createdAt: DateTime
  createdBy: UserRelateToOneForUpdateInput
  dict: DictRelateToManyForUpdateInput
  favoriteIn: DictItemFavoriteRelateToManyForUpdateInput
}

input DictRelateToManyForUpdateInput {
  disconnect: [DictWhereUniqueInput!]
  set: [DictWhereUniqueInput!]
  create: [DictCreateInput!]
  connect: [DictWhereUniqueInput!]
}

input DictItemUpdateArgs {
  where: DictItemWhereUniqueInput!
  data: DictItemUpdateInput!
}

input DictItemCreateInput {
  name: String
  trans: JSON
  example: String
  exTrans: JSON
  createdAt: DateTime
  createdBy: UserRelateToOneForCreateInput
  dict: DictRelateToManyForCreateInput
  favoriteIn: DictItemFavoriteRelateToManyForCreateInput
}

input DictRelateToManyForCreateInput {
  create: [DictCreateInput!]
  connect: [DictWhereUniqueInput!]
}

type DictItemFavorite {
  id: ID!
  dict: Dict
  item: DictItem
  favoritedAt: DateTime
}

input DictItemFavoriteWhereUniqueInput {
  id: ID
}

input DictItemFavoriteWhereInput {
  AND: [DictItemFavoriteWhereInput!]
  OR: [DictItemFavoriteWhereInput!]
  NOT: [DictItemFavoriteWhereInput!]
  id: IDFilter
  dict: DictWhereInput
  item: DictItemWhereInput
  favoritedAt: DateTimeNullableFilter
}

input DictItemFavoriteOrderByInput {
  id: OrderDirection
  favoritedAt: OrderDirection
}

input DictItemFavoriteUpdateInput {
  dict: DictRelateToOneForUpdateInput
  item: DictItemRelateToOneForUpdateInput
  favoritedAt: DateTime
}

input DictRelateToOneForUpdateInput {
  create: DictCreateInput
  connect: DictWhereUniqueInput
  disconnect: Boolean
}

input DictItemRelateToOneForUpdateInput {
  create: DictItemCreateInput
  connect: DictItemWhereUniqueInput
  disconnect: Boolean
}

input DictItemFavoriteUpdateArgs {
  where: DictItemFavoriteWhereUniqueInput!
  data: DictItemFavoriteUpdateInput!
}

input DictItemFavoriteCreateInput {
  dict: DictRelateToOneForCreateInput
  item: DictItemRelateToOneForCreateInput
  favoritedAt: DateTime
}

input DictRelateToOneForCreateInput {
  create: DictCreateInput
  connect: DictWhereUniqueInput
}

input DictItemRelateToOneForCreateInput {
  create: DictItemCreateInput
  connect: DictItemWhereUniqueInput
}

type Article {
  id: ID!
  title: String
  type: ArticleTypeType
  poster: String
  description: String
  subtitles: JSON
  content: String
  createdAt: DateTime
  createdBy: User
}

enum ArticleTypeType {
  MOVIE
  TEXT
  EPUB
}

input ArticleWhereUniqueInput {
  id: ID
}

input ArticleWhereInput {
  AND: [ArticleWhereInput!]
  OR: [ArticleWhereInput!]
  NOT: [ArticleWhereInput!]
  id: IDFilter
  title: StringFilter
  type: ArticleTypeTypeNullableFilter
  poster: StringFilter
  description: StringFilter
  content: StringFilter
  createdAt: DateTimeNullableFilter
  createdBy: UserWhereInput
}

input ArticleTypeTypeNullableFilter {
  equals: ArticleTypeType
  in: [ArticleTypeType!]
  notIn: [ArticleTypeType!]
  not: ArticleTypeTypeNullableFilter
}

input ArticleOrderByInput {
  id: OrderDirection
  title: OrderDirection
  type: OrderDirection
  poster: OrderDirection
  description: OrderDirection
  content: OrderDirection
  createdAt: OrderDirection
}

input ArticleUpdateInput {
  title: String
  type: ArticleTypeType
  poster: String
  description: String
  subtitles: JSON
  content: String
  createdAt: DateTime
  createdBy: UserRelateToOneForUpdateInput
}

input ArticleUpdateArgs {
  where: ArticleWhereUniqueInput!
  data: ArticleUpdateInput!
}

input ArticleCreateInput {
  title: String
  type: ArticleTypeType
  poster: String
  description: String
  subtitles: JSON
  content: String
  createdAt: DateTime
  createdBy: UserRelateToOneForCreateInput
}

type Annotation {
  id: ID!
  type: AnnotationTypeType
  articleId: Article
  chapterId: String
  text: String
  content: String
  color: String
  createdAt: DateTime
  createdBy: User
  updatedAt: DateTime
  range: JSON
}

enum AnnotationTypeType {
  NOTE
  HIGHLIGHT
}

input AnnotationWhereUniqueInput {
  id: ID
}

input AnnotationWhereInput {
  AND: [AnnotationWhereInput!]
  OR: [AnnotationWhereInput!]
  NOT: [AnnotationWhereInput!]
  id: IDFilter
  type: AnnotationTypeTypeNullableFilter
  articleId: ArticleWhereInput
  chapterId: StringFilter
  text: StringFilter
  content: StringFilter
  color: StringFilter
  createdAt: DateTimeNullableFilter
  createdBy: UserWhereInput
  updatedAt: DateTimeNullableFilter
}

input AnnotationTypeTypeNullableFilter {
  equals: AnnotationTypeType
  in: [AnnotationTypeType!]
  notIn: [AnnotationTypeType!]
  not: AnnotationTypeTypeNullableFilter
}

input AnnotationOrderByInput {
  id: OrderDirection
  type: OrderDirection
  chapterId: OrderDirection
  text: OrderDirection
  content: OrderDirection
  color: OrderDirection
  createdAt: OrderDirection
  updatedAt: OrderDirection
}

input AnnotationUpdateInput {
  type: AnnotationTypeType
  articleId: ArticleRelateToOneForUpdateInput
  chapterId: String
  text: String
  content: String
  color: String
  createdAt: DateTime
  createdBy: UserRelateToOneForUpdateInput
  updatedAt: DateTime
  range: JSON
}

input ArticleRelateToOneForUpdateInput {
  create: ArticleCreateInput
  connect: ArticleWhereUniqueInput
  disconnect: Boolean
}

input AnnotationUpdateArgs {
  where: AnnotationWhereUniqueInput!
  data: AnnotationUpdateInput!
}

input AnnotationCreateInput {
  type: AnnotationTypeType
  articleId: ArticleRelateToOneForCreateInput
  chapterId: String
  text: String
  content: String
  color: String
  createdAt: DateTime
  createdBy: UserRelateToOneForCreateInput
  updatedAt: DateTime
  range: JSON
}

input ArticleRelateToOneForCreateInput {
  create: ArticleCreateInput
  connect: ArticleWhereUniqueInput
}

"""
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]
  createPushSubscription(data: PushSubscriptionCreateInput!): PushSubscription
  createPushSubscriptions(data: [PushSubscriptionCreateInput!]!): [PushSubscription]
  updatePushSubscription(where: PushSubscriptionWhereUniqueInput!, data: PushSubscriptionUpdateInput!): PushSubscription
  updatePushSubscriptions(data: [PushSubscriptionUpdateArgs!]!): [PushSubscription]
  deletePushSubscription(where: PushSubscriptionWhereUniqueInput!): PushSubscription
  deletePushSubscriptions(where: [PushSubscriptionWhereUniqueInput!]!): [PushSubscription]
  createTopik(data: TopikCreateInput!): Topik
  createTopiks(data: [TopikCreateInput!]!): [Topik]
  updateTopik(where: TopikWhereUniqueInput!, data: TopikUpdateInput!): Topik
  updateTopiks(data: [TopikUpdateArgs!]!): [Topik]
  deleteTopik(where: TopikWhereUniqueInput!): Topik
  deleteTopiks(where: [TopikWhereUniqueInput!]!): [Topik]
  createDict(data: DictCreateInput!): Dict
  createDicts(data: [DictCreateInput!]!): [Dict]
  updateDict(where: DictWhereUniqueInput!, data: DictUpdateInput!): Dict
  updateDicts(data: [DictUpdateArgs!]!): [Dict]
  deleteDict(where: DictWhereUniqueInput!): Dict
  deleteDicts(where: [DictWhereUniqueInput!]!): [Dict]
  createDictItem(data: DictItemCreateInput!): DictItem
  createDictItems(data: [DictItemCreateInput!]!): [DictItem]
  updateDictItem(where: DictItemWhereUniqueInput!, data: DictItemUpdateInput!): DictItem
  updateDictItems(data: [DictItemUpdateArgs!]!): [DictItem]
  deleteDictItem(where: DictItemWhereUniqueInput!): DictItem
  deleteDictItems(where: [DictItemWhereUniqueInput!]!): [DictItem]
  createDictItemFavorite(data: DictItemFavoriteCreateInput!): DictItemFavorite
  createDictItemFavorites(data: [DictItemFavoriteCreateInput!]!): [DictItemFavorite]
  updateDictItemFavorite(where: DictItemFavoriteWhereUniqueInput!, data: DictItemFavoriteUpdateInput!): DictItemFavorite
  updateDictItemFavorites(data: [DictItemFavoriteUpdateArgs!]!): [DictItemFavorite]
  deleteDictItemFavorite(where: DictItemFavoriteWhereUniqueInput!): DictItemFavorite
  deleteDictItemFavorites(where: [DictItemFavoriteWhereUniqueInput!]!): [DictItemFavorite]
  createArticle(data: ArticleCreateInput!): Article
  createArticles(data: [ArticleCreateInput!]!): [Article]
  updateArticle(where: ArticleWhereUniqueInput!, data: ArticleUpdateInput!): Article
  updateArticles(data: [ArticleUpdateArgs!]!): [Article]
  deleteArticle(where: ArticleWhereUniqueInput!): Article
  deleteArticles(where: [ArticleWhereUniqueInput!]!): [Article]
  createAnnotation(data: AnnotationCreateInput!): Annotation
  createAnnotations(data: [AnnotationCreateInput!]!): [Annotation]
  updateAnnotation(where: AnnotationWhereUniqueInput!, data: AnnotationUpdateInput!): Annotation
  updateAnnotations(data: [AnnotationUpdateArgs!]!): [Annotation]
  deleteAnnotation(where: AnnotationWhereUniqueInput!): Annotation
  deleteAnnotations(where: [AnnotationWhereUniqueInput!]!): [Annotation]
  endSession: Boolean!
  authenticateUserWithPassword(email: String!, password: String!): UserAuthenticationWithPasswordResult
  createInitialUser(data: CreateInitialUserInput!): UserAuthenticationWithPasswordSuccess!
}

union UserAuthenticationWithPasswordResult = UserAuthenticationWithPasswordSuccess | UserAuthenticationWithPasswordFailure

type UserAuthenticationWithPasswordSuccess {
  sessionToken: String!
  item: User!
}

type UserAuthenticationWithPasswordFailure {
  message: String!
}

input CreateInitialUserInput {
  name: String
  email: String
  password: String
}

type Query {
  user(where: UserWhereUniqueInput!): User
  users(where: UserWhereInput! = {}, orderBy: [UserOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: UserWhereUniqueInput): [User!]
  usersCount(where: UserWhereInput! = {}): Int
  pushSubscription(where: PushSubscriptionWhereUniqueInput!): PushSubscription
  pushSubscriptions(where: PushSubscriptionWhereInput! = {}, orderBy: [PushSubscriptionOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: PushSubscriptionWhereUniqueInput): [PushSubscription!]
  pushSubscriptionsCount(where: PushSubscriptionWhereInput! = {}): Int
  topik(where: TopikWhereUniqueInput!): Topik
  topiks(where: TopikWhereInput! = {}, orderBy: [TopikOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: TopikWhereUniqueInput): [Topik!]
  topiksCount(where: TopikWhereInput! = {}): Int
  dict(where: DictWhereUniqueInput!): Dict
  dicts(where: DictWhereInput! = {}, orderBy: [DictOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictWhereUniqueInput): [Dict!]
  dictsCount(where: DictWhereInput! = {}): Int
  dictItem(where: DictItemWhereUniqueInput!): DictItem
  dictItems(where: DictItemWhereInput! = {}, orderBy: [DictItemOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictItemWhereUniqueInput): [DictItem!]
  dictItemsCount(where: DictItemWhereInput! = {}): Int
  dictItemFavorite(where: DictItemFavoriteWhereUniqueInput!): DictItemFavorite
  dictItemFavorites(where: DictItemFavoriteWhereInput! = {}, orderBy: [DictItemFavoriteOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: DictItemFavoriteWhereUniqueInput): [DictItemFavorite!]
  dictItemFavoritesCount(where: DictItemFavoriteWhereInput! = {}): Int
  article(where: ArticleWhereUniqueInput!): Article
  articles(where: ArticleWhereInput! = {}, orderBy: [ArticleOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: ArticleWhereUniqueInput): [Article!]
  articlesCount(where: ArticleWhereInput! = {}): Int
  annotation(where: AnnotationWhereUniqueInput!): Annotation
  annotations(where: AnnotationWhereInput! = {}, orderBy: [AnnotationOrderByInput!]! = [], take: Int, skip: Int! = 0, cursor: AnnotationWhereUniqueInput): [Annotation!]
  annotationsCount(where: AnnotationWhereInput! = {}): Int
  keystone: KeystoneMeta!
  authenticatedItem: AuthenticatedItem
}

union AuthenticatedItem = User

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!]!
  graphql: KeystoneAdminUIGraphQL!
  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 KeystoneAdminUIGraphQL {
  names: KeystoneAdminUIGraphQLNames!
}

type KeystoneAdminUIGraphQLNames {
  outputTypeName: String!
  whereInputName: String!
  whereUniqueInputName: String!
  createInputName: String!
  createMutationName: String!
  createManyMutationName: String!
  relateToOneForCreateInputName: String!
  relateToManyForCreateInputName: String!
  itemQueryName: String!
  listOrderName: String!
  listQueryCountName: String!
  listQueryName: String!
  updateInputName: String!
  updateMutationName: String!
  updateManyInputName: String!
  updateManyMutationName: String!
  relateToOneForUpdateInputName: String!
  relateToManyForUpdateInputName: String!
  deleteMutationName: String!
  deleteManyMutationName: String!
}

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

enum KeystoneAdminUISortDirection {
  ASC
  DESC
}