schema.graphql

schema {
  query: Query
  mutation: Mutation
}

"""
Directs the executor to defer this fragment when the `if` argument is true or undefined.
"""
directive @defer(
  """Deferred when true or undefined."""
  if: Boolean = true
  """Unique name"""
  label: String
) on FRAGMENT_SPREAD | INLINE_FRAGMENT

directive @goField(forceResolver: Boolean, name: String, omittable: Boolean) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION

directive @goModel(forceGenerate: Boolean, model: String, models: [String!]) on ENUM | INPUT_OBJECT | INTERFACE | OBJECT | SCALAR | UNION

directive @scope(scope: String!) on FIELD_DEFINITION

type CheatRecord implements Node {
  cheatedAt: Time!
  id: ID!
  reason: String!
  resolvedAt: Time
  resolvedReason: String
  user: User!
}

"""A connection to a list of items."""
type CheatRecordConnection {
  """A list of edges."""
  edges: [CheatRecordEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""An edge in a connection."""
type CheatRecordEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: CheatRecord
}

"""
CheatRecordWhereInput is used for filtering CheatRecord objects.
Input was generated by ent.
"""
input CheatRecordWhereInput {
  and: [CheatRecordWhereInput!]
  """cheated_at field predicates"""
  cheatedAt: Time
  cheatedAtGT: Time
  cheatedAtGTE: Time
  cheatedAtIn: [Time!]
  cheatedAtLT: Time
  cheatedAtLTE: Time
  cheatedAtNEQ: Time
  cheatedAtNotIn: [Time!]
  """user edge predicates"""
  hasUser: Boolean
  hasUserWith: [UserWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: CheatRecordWhereInput
  or: [CheatRecordWhereInput!]
  """reason field predicates"""
  reason: String
  reasonContains: String
  reasonContainsFold: String
  reasonEqualFold: String
  reasonGT: String
  reasonGTE: String
  reasonHasPrefix: String
  reasonHasSuffix: String
  reasonIn: [String!]
  reasonLT: String
  reasonLTE: String
  reasonNEQ: String
  reasonNotIn: [String!]
  """resolved_at field predicates"""
  resolvedAt: Time
  resolvedAtGT: Time
  resolvedAtGTE: Time
  resolvedAtIn: [Time!]
  resolvedAtIsNil: Boolean
  resolvedAtLT: Time
  resolvedAtLTE: Time
  resolvedAtNEQ: Time
  resolvedAtNotIn: [Time!]
  resolvedAtNotNil: Boolean
  """resolved_reason field predicates"""
  resolvedReason: String
  resolvedReasonContains: String
  resolvedReasonContainsFold: String
  resolvedReasonEqualFold: String
  resolvedReasonGT: String
  resolvedReasonGTE: String
  resolvedReasonHasPrefix: String
  resolvedReasonHasSuffix: String
  resolvedReasonIn: [String!]
  resolvedReasonIsNil: Boolean
  resolvedReasonLT: String
  resolvedReasonLTE: String
  resolvedReasonNEQ: String
  resolvedReasonNotIn: [String!]
  resolvedReasonNotNil: Boolean
}

"""
CreateDatabaseInput is used for create Database object.
Input was generated by ent.
"""
input CreateDatabaseInput {
  description: String
  questionIDs: [ID!]
  """relation figure"""
  relationFigure: String!
  """SQL schema"""
  schema: String!
  slug: String!
}

"""
CreateGroupInput is used for create Group object.
Input was generated by ent.
"""
input CreateGroupInput {
  description: String
  name: String!
  scopeSetIDs: [ID!]
}

"""
CreatePointInput is used for create Point object.
Input was generated by ent.
"""
input CreatePointInput {
  description: String
  grantedAt: Time
  points: Int
  userID: ID!
}

"""
CreateQuestionInput is used for create Question object.
Input was generated by ent.
"""
input CreateQuestionInput {
  """Question category, e.g. 'query'"""
  category: String!
  databaseID: ID!
  """Question stem"""
  description: String!
  """Question difficulty, e.g. 'easy'"""
  difficulty: QuestionDifficulty
  """Reference answer"""
  referenceAnswer: String!
  submissionIDs: [ID!]
  """Question title"""
  title: String!
  """
  Only the users with this scope set can see the question. Empty means visible to everyone.
  """
  visibleScope: String
}

"""
CreateScopeSetInput is used for create ScopeSet object.
Input was generated by ent.
"""
input CreateScopeSetInput {
  description: String
  groupIDs: [ID!]
  scopes: [String!]
  slug: String!
}

"""
CreateUserInput is used for create User object.
Input was generated by ent.
"""
input CreateUserInput {
  avatar: String
  cheatRecordIDs: [ID!]
  email: String!
  eventIDs: [ID!]
  groupID: ID!
  name: String!
  pointIDs: [ID!]
  submissionIDs: [ID!]
}

"""
Define a Relay Cursor type:
https://relay.dev/graphql/connections.htm#sec-Cursor
"""
scalar Cursor

type Database implements Node {
  description: String
  id: ID!
  questions: [Question!]
  """relation figure"""
  relationFigure: String!
  """SQL schema"""
  schema: String!
  slug: String!
  structure: DatabaseStructure!
}

type DatabaseStructure {
  tables: [DatabaseTable!]!
}

type DatabaseTable {
  columns: [String!]!
  name: String!
}

"""
DatabaseWhereInput is used for filtering Database objects.
Input was generated by ent.
"""
input DatabaseWhereInput {
  and: [DatabaseWhereInput!]
  """description field predicates"""
  description: String
  descriptionContains: String
  descriptionContainsFold: String
  descriptionEqualFold: String
  descriptionGT: String
  descriptionGTE: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIn: [String!]
  descriptionIsNil: Boolean
  descriptionLT: String
  descriptionLTE: String
  descriptionNEQ: String
  descriptionNotIn: [String!]
  descriptionNotNil: Boolean
  """questions edge predicates"""
  hasQuestions: Boolean
  hasQuestionsWith: [QuestionWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: DatabaseWhereInput
  or: [DatabaseWhereInput!]
  """relation_figure field predicates"""
  relationFigure: String
  relationFigureContains: String
  relationFigureContainsFold: String
  relationFigureEqualFold: String
  relationFigureGT: String
  relationFigureGTE: String
  relationFigureHasPrefix: String
  relationFigureHasSuffix: String
  relationFigureIn: [String!]
  relationFigureLT: String
  relationFigureLTE: String
  relationFigureNEQ: String
  relationFigureNotIn: [String!]
  """schema field predicates"""
  schema: String
  schemaContains: String
  schemaContainsFold: String
  schemaEqualFold: String
  schemaGT: String
  schemaGTE: String
  schemaHasPrefix: String
  schemaHasSuffix: String
  schemaIn: [String!]
  schemaLT: String
  schemaLTE: String
  schemaNEQ: String
  schemaNotIn: [String!]
  """slug field predicates"""
  slug: String
  slugContains: String
  slugContainsFold: String
  slugEqualFold: String
  slugGT: String
  slugGTE: String
  slugHasPrefix: String
  slugHasSuffix: String
  slugIn: [String!]
  slugLT: String
  slugLTE: String
  slugNEQ: String
  slugNotIn: [String!]
}

type Event implements Node {
  id: ID!
  payload: Map
  triggeredAt: Time!
  type: String!
  user: User!
  userID: ID!
}

"""A connection to a list of items."""
type EventConnection {
  """A list of edges."""
  edges: [EventEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""An edge in a connection."""
type EventEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: Event
}

"""Ordering options for Event connections"""
input EventOrder {
  """The ordering direction."""
  direction: OrderDirection! = ASC
  """The field by which to order Events."""
  field: EventOrderField!
}

"""Properties by which Event connections can be ordered."""
enum EventOrderField {
  TRIGGERED_AT
}

"""
EventWhereInput is used for filtering Event objects.
Input was generated by ent.
"""
input EventWhereInput {
  and: [EventWhereInput!]
  """user edge predicates"""
  hasUser: Boolean
  hasUserWith: [UserWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: EventWhereInput
  or: [EventWhereInput!]
  """triggered_at field predicates"""
  triggeredAt: Time
  triggeredAtGT: Time
  triggeredAtGTE: Time
  triggeredAtIn: [Time!]
  triggeredAtLT: Time
  triggeredAtLTE: Time
  triggeredAtNEQ: Time
  triggeredAtNotIn: [Time!]
  """type field predicates"""
  type: String
  typeContains: String
  typeContainsFold: String
  typeEqualFold: String
  typeGT: String
  typeGTE: String
  typeHasPrefix: String
  typeHasSuffix: String
  typeIn: [String!]
  typeLT: String
  typeLTE: String
  typeNEQ: String
  typeNotIn: [String!]
  """user_id field predicates"""
  userID: ID
  userIDIn: [ID!]
  userIDNEQ: ID
  userIDNotIn: [ID!]
}

type Group implements Node {
  createdAt: Time!
  deletedAt: Time
  description: String
  id: ID!
  name: String!
  scopeSets: [ScopeSet!]
  updatedAt: Time!
}

"""
GroupWhereInput is used for filtering Group objects.
Input was generated by ent.
"""
input GroupWhereInput {
  and: [GroupWhereInput!]
  """created_at field predicates"""
  createdAt: Time
  createdAtGT: Time
  createdAtGTE: Time
  createdAtIn: [Time!]
  createdAtLT: Time
  createdAtLTE: Time
  createdAtNEQ: Time
  createdAtNotIn: [Time!]
  """deleted_at field predicates"""
  deletedAt: Time
  deletedAtGT: Time
  deletedAtGTE: Time
  deletedAtIn: [Time!]
  deletedAtIsNil: Boolean
  deletedAtLT: Time
  deletedAtLTE: Time
  deletedAtNEQ: Time
  deletedAtNotIn: [Time!]
  deletedAtNotNil: Boolean
  """description field predicates"""
  description: String
  descriptionContains: String
  descriptionContainsFold: String
  descriptionEqualFold: String
  descriptionGT: String
  descriptionGTE: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIn: [String!]
  descriptionIsNil: Boolean
  descriptionLT: String
  descriptionLTE: String
  descriptionNEQ: String
  descriptionNotIn: [String!]
  descriptionNotNil: Boolean
  """scope_sets edge predicates"""
  hasScopeSets: Boolean
  hasScopeSetsWith: [ScopeSetWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  """name field predicates"""
  name: String
  nameContains: String
  nameContainsFold: String
  nameEqualFold: String
  nameGT: String
  nameGTE: String
  nameHasPrefix: String
  nameHasSuffix: String
  nameIn: [String!]
  nameLT: String
  nameLTE: String
  nameNEQ: String
  nameNotIn: [String!]
  not: GroupWhereInput
  or: [GroupWhereInput!]
  """updated_at field predicates"""
  updatedAt: Time
  updatedAtGT: Time
  updatedAtGTE: Time
  updatedAtIn: [Time!]
  updatedAtLT: Time
  updatedAtLTE: Time
  updatedAtNEQ: Time
  updatedAtNotIn: [Time!]
}

"""The builtin Map type"""
scalar Map

type Mutation {
  """
  Create a new cheat record for a user.
  
  If userID is not provided, the current user will be used.
  For this case, you should have "me:write" scope.
  
  If userID is provided, you should have "cheat_record:write" scope.
  """
  createCheatRecord(reason: String!, userID: ID): CheatRecord!
  """Create a database."""
  createDatabase(input: CreateDatabaseInput!): Database!
  """Create a new group."""
  createGroup(input: CreateGroupInput!): Group
  """Create a new point record for a user."""
  createPoint(input: CreatePointInput!): Point
  """Create a question."""
  createQuestion(input: CreateQuestionInput!): Question!
  """Create a new scope set."""
  createScopeSet(input: CreateScopeSetInput!): ScopeSet
  """Delete a database."""
  deleteDatabase(id: ID!): Boolean!
  """Delete a group."""
  deleteGroup(id: ID!): Boolean!
  """Delete a question."""
  deleteQuestion(id: ID!): Boolean!
  """Delete a scope set."""
  deleteScopeSet(id: ID!): Boolean!
  """Delete a user."""
  deleteUser(id: ID!): Boolean!
  """
  Impersonate a user.
  
  Returns the token of the impersonated user.
  You can then use the token to access the user's resources.
  """
  impersonateUser(userID: ID!): String!
  """Logout from all the devices of the current user."""
  logoutAll: Boolean!
  """Logout a user from all his devices."""
  logoutUser(userID: ID!): Boolean!
  """Resolve a cheat record."""
  resolveCheatRecord(cheatRecordID: ID!, reason: String!): Boolean!
  """Submit your answer to a question."""
  submitAnswer(answer: String!, id: ID!): SubmissionResult!
  """Update a database."""
  updateDatabase(id: ID!, input: UpdateDatabaseInput!): Database!
  """Update a group."""
  updateGroup(id: ID!, input: UpdateGroupInput!): Group
  """Update the information of the current user."""
  updateMe(input: UpdateUserInput!): User
  """Update a question."""
  updateQuestion(id: ID!, input: UpdateQuestionInput!): Question!
  """Update a scope set."""
  updateScopeSet(id: ID!, input: UpdateScopeSetInput!): ScopeSet
  """Update the information of a user."""
  updateUser(id: ID!, input: UpdateUserInput!): User
}

"""
An object with an ID.
Follows the [Relay Global Object Identification Specification](https://relay.dev/graphql/objectidentification.htm)
"""
interface Node {
  """The id of the object."""
  id: ID!
}

"""
Possible directions in which to order a list of items when provided an `orderBy` argument.
"""
enum OrderDirection {
  """Specifies an ascending order for a given `orderBy` argument."""
  ASC
  """Specifies a descending order for a given `orderBy` argument."""
  DESC
}

"""
Information about pagination in a connection.
https://relay.dev/graphql/connections.htm#sec-undefined.PageInfo
"""
type PageInfo {
  """When paginating forwards, the cursor to continue."""
  endCursor: Cursor
  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!
  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!
  """When paginating backwards, the cursor to continue."""
  startCursor: Cursor
}

type Point implements Node {
  description: String
  grantedAt: Time!
  id: ID!
  points: Int!
  user: User!
}

"""A connection to a list of items."""
type PointConnection {
  """A list of edges."""
  edges: [PointEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""An edge in a connection."""
type PointEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: Point
}

"""Ordering options for Point connections"""
input PointOrder {
  """The ordering direction."""
  direction: OrderDirection! = ASC
  """The field by which to order Points."""
  field: PointOrderField!
}

"""Properties by which Point connections can be ordered."""
enum PointOrderField {
  GRANTED_AT
}

"""
PointWhereInput is used for filtering Point objects.
Input was generated by ent.
"""
input PointWhereInput {
  and: [PointWhereInput!]
  """description field predicates"""
  description: String
  descriptionContains: String
  descriptionContainsFold: String
  descriptionEqualFold: String
  descriptionGT: String
  descriptionGTE: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIn: [String!]
  descriptionIsNil: Boolean
  descriptionLT: String
  descriptionLTE: String
  descriptionNEQ: String
  descriptionNotIn: [String!]
  descriptionNotNil: Boolean
  """granted_at field predicates"""
  grantedAt: Time
  grantedAtGT: Time
  grantedAtGTE: Time
  grantedAtIn: [Time!]
  grantedAtLT: Time
  grantedAtLTE: Time
  grantedAtNEQ: Time
  grantedAtNotIn: [Time!]
  """user edge predicates"""
  hasUser: Boolean
  hasUserWith: [UserWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: PointWhereInput
  or: [PointWhereInput!]
  """points field predicates"""
  points: Int
  pointsGT: Int
  pointsGTE: Int
  pointsIn: [Int!]
  pointsLT: Int
  pointsLTE: Int
  pointsNEQ: Int
  pointsNotIn: [Int!]
}

type Query {
  """Get a cheat record by ID."""
  cheatRecord(id: ID!): CheatRecord!
  cheatRecords(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Filtering options for CheatRecords returned from the connection."""
    where: CheatRecordWhereInput
  ): CheatRecordConnection!
  """Get a database by ID."""
  database(id: ID!): Database!
  databases: [Database!]!
  """
  Get an event by ID.
  
  If you have the "event:read" scope, you can get any event by ID;
  otherwise, you can only get your own events.
  """
  event(id: ID!): Event!
  events(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Events returned from the connection."""
    orderBy: EventOrder
    """Filtering options for Events returned from the connection."""
    where: EventWhereInput
  ): EventConnection!
  """Get a group by ID."""
  group(id: ID!): Group!
  groups: [Group!]!
  me: User!
  """Fetches an object given its ID."""
  node(
    """ID of the object."""
    id: ID!
  ): Node
  """Lookup nodes by a list of IDs."""
  nodes(
    """The list of node IDs."""
    ids: [ID!]!
  ): [Node]!
  """
  Get a point grant by ID.
  
  If you have the "point:read" scope, you can get any point grant by ID;
  otherwise, you can only get your own point grants.
  """
  pointGrant(id: ID!): Point!
  points(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Points returned from the connection."""
    orderBy: PointOrder
    """Filtering options for Points returned from the connection."""
    where: PointWhereInput
  ): PointConnection!
  """Get a question by ID."""
  question(id: ID!): Question!
  """Get the list of question categories."""
  questionCategories: [String!]!
  questions(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Questions returned from the connection."""
    orderBy: QuestionOrder
    """Filtering options for Questions returned from the connection."""
    where: QuestionWhereInput
  ): QuestionConnection!
  """Get the ranking."""
  ranking(after: Cursor, filter: RankingFilter!, first: Int): RankingConnection!
  """Get a scope set by ID or slug."""
  scopeSet(filter: ScopeSetFilter!): ScopeSet!
  scopeSets: [ScopeSet!]!
  """
  Get a submission by ID.
  
  If you have the "submission:read" scope, you can get any submission by ID;
  otherwise, you can only get your own submissions.
  """
  submission(id: ID!): Submission!
  submissions(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Submissions returned from the connection."""
    orderBy: SubmissionOrder
    """Filtering options for Submissions returned from the connection."""
    where: SubmissionWhereInput
  ): SubmissionConnection!
  """Get a user by ID."""
  user(id: ID!): User!
  users(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Users returned from the connection."""
    orderBy: UserOrder
    """Filtering options for Users returned from the connection."""
    where: UserWhereInput
  ): UserConnection!
}

type Question implements Node {
  """Have you tried to solve the question?"""
  attempted: Boolean!
  """Question category, e.g. 'query'"""
  category: String!
  database: Database!
  """Question stem"""
  description: String!
  """Question difficulty, e.g. 'easy'"""
  difficulty: QuestionDifficulty!
  id: ID!
  """Get the last submission for this question."""
  lastSubmission: Submission
  """Reference answer"""
  referenceAnswer: String!
  referenceAnswerResult: SQLExecutionResult!
  """Have you solved the question?"""
  solved: Boolean!
  """The statistics of the question, e.g. pass rate."""
  statistics: QuestionStatistics!
  submissions(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Submissions returned from the connection."""
    orderBy: SubmissionOrder
    """Filtering options for Submissions returned from the connection."""
    where: SubmissionWhereInput
  ): SubmissionConnection!
  """Question title"""
  title: String!
  """
  List of your submissions for this question, ordered by submitted at descending.
  """
  userSubmissions: [Submission!]!
  """
  Only the users with this scope set can see the question. Empty means visible to everyone.
  """
  visibleScope: String
}

"""A connection to a list of items."""
type QuestionConnection {
  """A list of edges."""
  edges: [QuestionEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""QuestionDifficulty is enum for the field difficulty"""
enum QuestionDifficulty {
  easy
  hard
  medium
  unspecified
}

"""An edge in a connection."""
type QuestionEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: Question
}

"""Ordering options for Question connections"""
input QuestionOrder {
  """The ordering direction."""
  direction: OrderDirection! = ASC
  """The field by which to order Questions."""
  field: QuestionOrderField!
}

"""Properties by which Question connections can be ordered."""
enum QuestionOrderField {
  CATEGORY
  DIFFICULTY
}

type QuestionStatistics {
  """Number of users who attempted"""
  attemptedUsers: Int!
  """Number of correct submissions"""
  correctSubmissionCount: Int!
  """Number of users who passed"""
  passedUsers: Int!
  """Total number of submissions"""
  submissionCount: Int!
}

"""
QuestionWhereInput is used for filtering Question objects.
Input was generated by ent.
"""
input QuestionWhereInput {
  and: [QuestionWhereInput!]
  """category field predicates"""
  category: String
  categoryContains: String
  categoryContainsFold: String
  categoryEqualFold: String
  categoryGT: String
  categoryGTE: String
  categoryHasPrefix: String
  categoryHasSuffix: String
  categoryIn: [String!]
  categoryLT: String
  categoryLTE: String
  categoryNEQ: String
  categoryNotIn: [String!]
  """description field predicates"""
  description: String
  descriptionContains: String
  descriptionContainsFold: String
  descriptionEqualFold: String
  descriptionGT: String
  descriptionGTE: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIn: [String!]
  descriptionLT: String
  descriptionLTE: String
  descriptionNEQ: String
  descriptionNotIn: [String!]
  """difficulty field predicates"""
  difficulty: QuestionDifficulty
  difficultyIn: [QuestionDifficulty!]
  difficultyNEQ: QuestionDifficulty
  difficultyNotIn: [QuestionDifficulty!]
  """database edge predicates"""
  hasDatabase: Boolean
  hasDatabaseWith: [DatabaseWhereInput!]
  """submissions edge predicates"""
  hasSubmissions: Boolean
  hasSubmissionsWith: [SubmissionWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: QuestionWhereInput
  or: [QuestionWhereInput!]
  """reference_answer field predicates"""
  referenceAnswer: String
  referenceAnswerContains: String
  referenceAnswerContainsFold: String
  referenceAnswerEqualFold: String
  referenceAnswerGT: String
  referenceAnswerGTE: String
  referenceAnswerHasPrefix: String
  referenceAnswerHasSuffix: String
  referenceAnswerIn: [String!]
  referenceAnswerLT: String
  referenceAnswerLTE: String
  referenceAnswerNEQ: String
  referenceAnswerNotIn: [String!]
  """title field predicates"""
  title: String
  titleContains: String
  titleContainsFold: String
  titleEqualFold: String
  titleGT: String
  titleGTE: String
  titleHasPrefix: String
  titleHasSuffix: String
  titleIn: [String!]
  titleLT: String
  titleLTE: String
  titleNEQ: String
  titleNotIn: [String!]
  """visible_scope field predicates"""
  visibleScope: String
  visibleScopeContains: String
  visibleScopeContainsFold: String
  visibleScopeEqualFold: String
  visibleScopeGT: String
  visibleScopeGTE: String
  visibleScopeHasPrefix: String
  visibleScopeHasSuffix: String
  visibleScopeIn: [String!]
  visibleScopeIsNil: Boolean
  visibleScopeLT: String
  visibleScopeLTE: String
  visibleScopeNEQ: String
  visibleScopeNotIn: [String!]
  visibleScopeNotNil: Boolean
}

enum RankingBy {
  COMPLETED_QUESTIONS
  POINTS
}

type RankingConnection {
  edges: [RankingEdge!]!
  pageInfo: PageInfo!
  totalCount: Int!
}

type RankingEdge {
  cursor: Cursor!
  node: User!
  score: Int!
}

input RankingFilter {
  by: RankingBy!
  order: RankingOrder!
  period: RankingPeriod!
}

enum RankingOrder {
  ASC
  DESC
}

enum RankingPeriod {
  DAILY
  WEEKLY
}

type SQLExecutionResult {
  columns: [String!]!
  rows: [[String!]!]!
}

type ScopeSet implements Node {
  description: String
  groups: [Group!]
  id: ID!
  scopes: [String!]!
  slug: String!
}

"""
Filter for scope sets.

The filters are mutually exclusive, only one of them can be provided.
"""
input ScopeSetFilter {
  """The ID of the scope set."""
  id: ID
  """The slug of the scope set."""
  slug: String
}

"""
ScopeSetWhereInput is used for filtering ScopeSet objects.
Input was generated by ent.
"""
input ScopeSetWhereInput {
  and: [ScopeSetWhereInput!]
  """description field predicates"""
  description: String
  descriptionContains: String
  descriptionContainsFold: String
  descriptionEqualFold: String
  descriptionGT: String
  descriptionGTE: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIn: [String!]
  descriptionIsNil: Boolean
  descriptionLT: String
  descriptionLTE: String
  descriptionNEQ: String
  descriptionNotIn: [String!]
  descriptionNotNil: Boolean
  """groups edge predicates"""
  hasGroups: Boolean
  hasGroupsWith: [GroupWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: ScopeSetWhereInput
  or: [ScopeSetWhereInput!]
  """slug field predicates"""
  slug: String
  slugContains: String
  slugContainsFold: String
  slugEqualFold: String
  slugGT: String
  slugGTE: String
  slugHasPrefix: String
  slugHasSuffix: String
  slugIn: [String!]
  slugLT: String
  slugLTE: String
  slugNEQ: String
  slugNotIn: [String!]
}

type SolvedQuestionByDifficulty {
  difficulty: QuestionDifficulty!
  solvedQuestions: Int!
}

type Submission implements Node {
  error: String
  id: ID!
  queryResult: UserSQLExecutionResult
  question: Question!
  status: SubmissionStatus!
  submittedAt: Time!
  submittedCode: String!
  user: User!
}

"""A connection to a list of items."""
type SubmissionConnection {
  """A list of edges."""
  edges: [SubmissionEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""An edge in a connection."""
type SubmissionEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: Submission
}

"""Ordering options for Submission connections"""
input SubmissionOrder {
  """The ordering direction."""
  direction: OrderDirection! = ASC
  """The field by which to order Submissions."""
  field: SubmissionOrderField!
}

"""Properties by which Submission connections can be ordered."""
enum SubmissionOrderField {
  SUBMITTED_AT
}

type SubmissionResult {
  error: String
  result: UserSQLExecutionResult
}

type SubmissionStatistics {
  attemptedQuestions: Int!
  solvedQuestionByDifficulty: [SolvedQuestionByDifficulty!]!
  solvedQuestions: Int!
  totalQuestions: Int!
}

"""SubmissionStatus is enum for the field status"""
enum SubmissionStatus {
  failed
  pending
  success
}

"""
SubmissionWhereInput is used for filtering Submission objects.
Input was generated by ent.
"""
input SubmissionWhereInput {
  and: [SubmissionWhereInput!]
  """error field predicates"""
  error: String
  errorContains: String
  errorContainsFold: String
  errorEqualFold: String
  errorGT: String
  errorGTE: String
  errorHasPrefix: String
  errorHasSuffix: String
  errorIn: [String!]
  errorIsNil: Boolean
  errorLT: String
  errorLTE: String
  errorNEQ: String
  errorNotIn: [String!]
  errorNotNil: Boolean
  """question edge predicates"""
  hasQuestion: Boolean
  hasQuestionWith: [QuestionWhereInput!]
  """user edge predicates"""
  hasUser: Boolean
  hasUserWith: [UserWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  not: SubmissionWhereInput
  or: [SubmissionWhereInput!]
  """status field predicates"""
  status: SubmissionStatus
  statusIn: [SubmissionStatus!]
  statusNEQ: SubmissionStatus
  statusNotIn: [SubmissionStatus!]
  """submitted_at field predicates"""
  submittedAt: Time
  submittedAtGT: Time
  submittedAtGTE: Time
  submittedAtIn: [Time!]
  submittedAtLT: Time
  submittedAtLTE: Time
  submittedAtNEQ: Time
  submittedAtNotIn: [Time!]
  """submitted_code field predicates"""
  submittedCode: String
  submittedCodeContains: String
  submittedCodeContainsFold: String
  submittedCodeEqualFold: String
  submittedCodeGT: String
  submittedCodeGTE: String
  submittedCodeHasPrefix: String
  submittedCodeHasSuffix: String
  submittedCodeIn: [String!]
  submittedCodeLT: String
  submittedCodeLTE: String
  submittedCodeNEQ: String
  submittedCodeNotIn: [String!]
}

"""The builtin Time type"""
scalar Time

"""
UpdateDatabaseInput is used for update Database object.
Input was generated by ent.
"""
input UpdateDatabaseInput {
  addQuestionIDs: [ID!]
  clearDescription: Boolean
  clearQuestions: Boolean
  description: String
  """relation figure"""
  relationFigure: String
  removeQuestionIDs: [ID!]
  """SQL schema"""
  schema: String
}

"""
UpdateGroupInput is used for update Group object.
Input was generated by ent.
"""
input UpdateGroupInput {
  addScopeSetIDs: [ID!]
  clearDescription: Boolean
  clearScopeSets: Boolean
  description: String
  name: String
  removeScopeSetIDs: [ID!]
}

"""
UpdateQuestionInput is used for update Question object.
Input was generated by ent.
"""
input UpdateQuestionInput {
  addSubmissionIDs: [ID!]
  """Question category, e.g. 'query'"""
  category: String
  clearSubmissions: Boolean
  clearVisibleScope: Boolean
  databaseID: ID
  """Question stem"""
  description: String
  """Question difficulty, e.g. 'easy'"""
  difficulty: QuestionDifficulty
  """Reference answer"""
  referenceAnswer: String
  removeSubmissionIDs: [ID!]
  """Question title"""
  title: String
  """
  Only the users with this scope set can see the question. Empty means visible to everyone.
  """
  visibleScope: String
}

"""
UpdateScopeSetInput is used for update ScopeSet object.
Input was generated by ent.
"""
input UpdateScopeSetInput {
  addGroupIDs: [ID!]
  appendScopes: [String!]
  clearDescription: Boolean
  clearGroups: Boolean
  description: String
  removeGroupIDs: [ID!]
  scopes: [String!]
}

"""
UpdateUserInput is used for update User object.
Input was generated by ent.
"""
input UpdateUserInput {
  addCheatRecordIDs: [ID!]
  addEventIDs: [ID!]
  addPointIDs: [ID!]
  addSubmissionIDs: [ID!]
  avatar: String
  clearAvatar: Boolean
  clearCheatRecords: Boolean
  clearEvents: Boolean
  clearPoints: Boolean
  clearSubmissions: Boolean
  groupID: ID
  name: String
  removeCheatRecordIDs: [ID!]
  removeEventIDs: [ID!]
  removePointIDs: [ID!]
  removeSubmissionIDs: [ID!]
}

type User implements Node {
  avatar: String
  cheatRecords(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Filtering options for CheatRecords returned from the connection."""
    where: CheatRecordWhereInput
  ): CheatRecordConnection!
  """Does this user have any existing unresolved cheat records?"""
  cheating: Boolean!
  createdAt: Time!
  deletedAt: Time
  email: String!
  events(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Events returned from the connection."""
    orderBy: EventOrder
    """Filtering options for Events returned from the connection."""
    where: EventWhereInput
  ): EventConnection!
  group: Group!
  id: ID!
  """The user who impersonated this user."""
  impersonatedBy: User
  name: String!
  points(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Points returned from the connection."""
    orderBy: PointOrder
    """Filtering options for Points returned from the connection."""
    where: PointWhereInput
  ): PointConnection!
  submissionStatistics: SubmissionStatistics!
  submissions(
    """Returns the elements in the list that come after the specified cursor."""
    after: Cursor
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Ordering options for Submissions returned from the connection."""
    orderBy: SubmissionOrder
    """Filtering options for Submissions returned from the connection."""
    where: SubmissionWhereInput
  ): SubmissionConnection!
  """The total points of the user."""
  totalPoints: Int!
  updatedAt: Time!
}

"""A connection to a list of items."""
type UserConnection {
  """A list of edges."""
  edges: [UserEdge]
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """Identifies the total count of items in the connection."""
  totalCount: Int!
}

"""An edge in a connection."""
type UserEdge {
  """A cursor for use in pagination."""
  cursor: Cursor!
  """The item at the end of the edge."""
  node: User
}

"""Ordering options for User connections"""
input UserOrder {
  """The ordering direction."""
  direction: OrderDirection! = ASC
  """The field by which to order Users."""
  field: UserOrderField!
}

"""Properties by which User connections can be ordered."""
enum UserOrderField {
  EMAIL
}

type UserSQLExecutionResult {
  columns: [String!]!
  matchAnswer: Boolean!
  rows: [[String!]!]!
}

"""
UserWhereInput is used for filtering User objects.
Input was generated by ent.
"""
input UserWhereInput {
  and: [UserWhereInput!]
  """avatar field predicates"""
  avatar: String
  avatarContains: String
  avatarContainsFold: String
  avatarEqualFold: String
  avatarGT: String
  avatarGTE: String
  avatarHasPrefix: String
  avatarHasSuffix: String
  avatarIn: [String!]
  avatarIsNil: Boolean
  avatarLT: String
  avatarLTE: String
  avatarNEQ: String
  avatarNotIn: [String!]
  avatarNotNil: Boolean
  """created_at field predicates"""
  createdAt: Time
  createdAtGT: Time
  createdAtGTE: Time
  createdAtIn: [Time!]
  createdAtLT: Time
  createdAtLTE: Time
  createdAtNEQ: Time
  createdAtNotIn: [Time!]
  """deleted_at field predicates"""
  deletedAt: Time
  deletedAtGT: Time
  deletedAtGTE: Time
  deletedAtIn: [Time!]
  deletedAtIsNil: Boolean
  deletedAtLT: Time
  deletedAtLTE: Time
  deletedAtNEQ: Time
  deletedAtNotIn: [Time!]
  deletedAtNotNil: Boolean
  """email field predicates"""
  email: String
  emailContains: String
  emailContainsFold: String
  emailEqualFold: String
  emailGT: String
  emailGTE: String
  emailHasPrefix: String
  emailHasSuffix: String
  emailIn: [String!]
  emailLT: String
  emailLTE: String
  emailNEQ: String
  emailNotIn: [String!]
  """cheat_records edge predicates"""
  hasCheatRecords: Boolean
  hasCheatRecordsWith: [CheatRecordWhereInput!]
  """events edge predicates"""
  hasEvents: Boolean
  hasEventsWith: [EventWhereInput!]
  """group edge predicates"""
  hasGroup: Boolean
  hasGroupWith: [GroupWhereInput!]
  """points edge predicates"""
  hasPoints: Boolean
  hasPointsWith: [PointWhereInput!]
  """submissions edge predicates"""
  hasSubmissions: Boolean
  hasSubmissionsWith: [SubmissionWhereInput!]
  """id field predicates"""
  id: ID
  idGT: ID
  idGTE: ID
  idIn: [ID!]
  idLT: ID
  idLTE: ID
  idNEQ: ID
  idNotIn: [ID!]
  """name field predicates"""
  name: String
  nameContains: String
  nameContainsFold: String
  nameEqualFold: String
  nameGT: String
  nameGTE: String
  nameHasPrefix: String
  nameHasSuffix: String
  nameIn: [String!]
  nameLT: String
  nameLTE: String
  nameNEQ: String
  nameNotIn: [String!]
  not: UserWhereInput
  or: [UserWhereInput!]
  """updated_at field predicates"""
  updatedAt: Time
  updatedAtGT: Time
  updatedAtGTE: Time
  updatedAtIn: [Time!]
  updatedAtLT: Time
  updatedAtLTE: Time
  updatedAtNEQ: Time
  updatedAtNotIn: [Time!]
}