schema.graphql

type Account implements LegacyIDInterface & Node {
  """
  legacy canvas id
  """
  _id: ID!
  id: ID!
  name: String
  proficiencyRatingsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): ProficiencyRatingConnection
}

"""
A list of students that an `AssignmentOverride` applies to
"""
type AdhocStudents {
  students: [User!]
}

"""
The type of assessment
"""
enum AssessmentType {
  grading
  peer_review
  provisional_grade
}

type Assignment implements LegacyIDInterface & ModuleItemInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  allowGoogleDocsSubmission: Boolean

  """
  The number of submission attempts a student can make for this assignment. null implies unlimited.
  """
  allowedAttempts: Int

  """
  permitted uploaded file extensions (e.g. ['doc', 'xls', 'txt'])
  """
  allowedExtensions: [String!]
  anonymizeStudents: Boolean
  anonymousGrading: Boolean
  anonymousInstructorAnnotations: Boolean
  assignmentGroup: AssignmentGroup
  assignmentOverrides(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): AssignmentOverrideConnection
  canDuplicate: Boolean
  canUnpublish: Boolean
  course: Course
  createdAt: DateTime
  description: String
  discussion: Discussion

  """
  when this assignment is due
  """
  dueAt(
    """
    When true, return the overridden dates.

    Not all roles have permission to view un-overridden dates (in which
    case the overridden dates will be returned)
    """
    applyOverrides: Boolean = true
  ): DateTime
  dueDateRequired: Boolean
  expectsExternalSubmission: Boolean
  expectsSubmission: Boolean

  """
  If this is a group assignment, boolean flag indicating whether or not students will be graded individually.
  """
  gradeGroupStudentsIndividually: Boolean
  gradingType: GradingType
  groupSet: GroupSet

  """
  returns submissions grouped to one submission object per group
  """
  groupSubmissionsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionSearchFilterInput

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
    orderBy: [SubmissionSearchOrder!]
  ): SubmissionConnection

  """
  If true, the assignment has been submitted to by at least one student
  """
  hasSubmittedSubmissions: Boolean
  htmlUrl: URL
  id: ID!
  inClosedGradingPeriod: Boolean

  """
  the lock date (assignment is locked after this date)
  """
  lockAt(
    """
    When true, return the overridden dates.

    Not all roles have permission to view un-overridden dates (in which
    case the overridden dates will be returned)
    """
    applyOverrides: Boolean = true
  ): DateTime
  lockInfo: LockInfo
  moderatedGrading: ModeratedGrading
  modules: [Module!]
  muted: Boolean!
  name: String
  needsGradingCount: Int
  nonDigitalSubmission: Boolean

  """
  If true, the assignment will be omitted from the student's final grade
  """
  omitFromFinalGrade: Boolean

  """
  specifies that this assignment is only assigned to students for whom an
         `AssignmentOverride` applies.
  """
  onlyVisibleToOverrides: Boolean!
  peerReviews: PeerReviews

  """
  the assignment is out of this many points
  """
  pointsPossible: Float

  """
  determines the order this assignment is displayed in in its assignment group
  """
  position: Int
  postPolicy: PostPolicy

  """
  present if Sync Grades to SIS feature is enabled
  """
  postToSis: Boolean
  quiz: Quiz
  rubric: Rubric
  state: AssignmentState!
  submissionTypes: [SubmissionType!]

  """
  submissions for this assignment
  """
  submissionsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionSearchFilterInput

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
    orderBy: [SubmissionSearchOrder!]
  ): SubmissionConnection
  submissionsDownloads: Int
  timeZoneEdited: String

  """
  the unlock date (assignment is unlocked after this date)
  """
  unlockAt(
    """
    When true, return the overridden dates.

    Not all roles have permission to view un-overridden dates (in which
    case the overridden dates will be returned)
    """
    applyOverrides: Boolean = true
  ): DateTime
  updatedAt: DateTime
}

"""
The connection type for Assignment.
"""
type AssignmentConnection {
  """
  A list of edges.
  """
  edges: [AssignmentEdge]

  """
  A list of nodes.
  """
  nodes: [Assignment]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type AssignmentEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Assignment
}

input AssignmentFilter {
  """
  only return assignments for the given grading period. Defaults to
  the current grading period. Pass `null` to return all assignments
  (irrespective of the assignment's grading period)
  """
  gradingPeriodId: ID
}

type AssignmentGroup implements AssignmentsConnectionInterface & LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!

  """
  returns a list of assignments.

  **NOTE**: for courses with grading periods, this will only return grading
  periods in the current course; see `AssignmentFilter` for more info.
  In courses with grading periods that don't have students, it is necessary
  to *not* filter by grading period to list assignments.
  """
  assignmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: AssignmentFilter

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): AssignmentConnection
  createdAt: DateTime

  """
  grades for this assignment group
  """
  gradesConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GradesConnection
  groupWeight: Float
  id: ID!
  name: String
  position: Int
  rules: AssignmentGroupRules
  state: AssignmentGroupState!
  updatedAt: DateTime
}

"""
The connection type for AssignmentGroup.
"""
type AssignmentGroupConnection {
  """
  A list of edges.
  """
  edges: [AssignmentGroupEdge]

  """
  A list of nodes.
  """
  nodes: [AssignmentGroup]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type AssignmentGroupEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: AssignmentGroup
}

type AssignmentGroupRules {
  """
  The highest N assignments are not included in grade calculations
  """
  dropHighest: Int

  """
  The lowest N assignments are not included in grade calculations
  """
  dropLowest: Int
  neverDrop: [Assignment!]
}

"""
States that Assignment Group can be in
"""
enum AssignmentGroupState {
  available
  deleted
}

input AssignmentModeratedGradingUpdate {
  enabled: Boolean
  finalGraderId: ID
  graderCommentsVisibleToGraders: Boolean
  graderCount: Int
  graderNamesVisibleToFinalGrader: Boolean
  gradersAnonymousToGraders: Boolean
}

type AssignmentOverride implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  allDay: Boolean
  assignment: Assignment
  createdAt: DateTime
  dueAt: DateTime

  """
  ID of the object.
  """
  id: ID!
  lockAt: DateTime

  """
  This object specifies what students this override applies to
  """
  set: AssignmentOverrideSet
  title: String
  unlockAt: DateTime
  updatedAt: DateTime
}

"""
The connection type for AssignmentOverride.
"""
type AssignmentOverrideConnection {
  """
  A list of edges.
  """
  edges: [AssignmentOverrideEdge]

  """
  A list of nodes.
  """
  nodes: [AssignmentOverride]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

input AssignmentOverrideCreateOrUpdate {
  dueAt: DateTime
  groupId: ID
  id: ID
  lockAt: DateTime
  sectionId: ID
  studentIds: [ID!]
  unlockAt: DateTime
}

"""
An edge in a connection.
"""
type AssignmentOverrideEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: AssignmentOverride
}

"""
Objects that can be assigned overridden dates
"""
union AssignmentOverrideSet = AdhocStudents | Group | Section

input AssignmentPeerReviewsUpdate {
  anonymousReviews: Boolean
  automaticReviews: Boolean
  count: Int
  dueAt: DateTime
  enabled: Boolean
  intraReviews: Boolean
}

"""
States that an Assignment can be in
"""
enum AssignmentState {
  deleted
  published
  unpublished
}

interface AssignmentsConnectionInterface {
  """
  returns a list of assignments.

  **NOTE**: for courses with grading periods, this will only return grading
  periods in the current course; see `AssignmentFilter` for more info.
  In courses with grading periods that don't have students, it is necessary
  to *not* filter by grading period to list assignments.
  """
  assignmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: AssignmentFilter

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): AssignmentConnection
}

type AuditLogs {
  """
  A list of all recent graphql mutations run on the specified object
  """
  mutationLogs(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String
    assetString: String!

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    endTime: DateTime

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
    startTime: DateTime
  ): MutationLogConnection
}

"""
Determines if/how a leader is chosen for each group
"""
enum AutoLeaderPolicy {
  """
  the first student assigned to the group is the leader
  """
  first

  """
  a leader is chosen at random
  """
  random
}

type Course implements AssignmentsConnectionInterface & LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  account: Account
  assignmentGroupsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): AssignmentGroupConnection

  """
  PostPolicies for assignments within a course
  """
  assignmentPostPolicies(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): PostPolicyConnection

  """
  returns a list of assignments.

  **NOTE**: for courses with grading periods, this will only return grading
  periods in the current course; see `AssignmentFilter` for more info.
  In courses with grading periods that don't have students, it is necessary
  to *not* filter by grading period to list assignments.
  """
  assignmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: AssignmentFilter

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): AssignmentConnection

  """
  course short name
  """
  courseCode: String
  createdAt: DateTime
  externalToolsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: ExternalToolFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): ExternalToolConnection
  gradingPeriodsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GradingPeriodConnection

  """
  Project group sets for this course.
  """
  groupSetsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GroupSetConnection
  groupsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GroupConnection
  id: ID!
  modulesConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): ModuleConnection
  name: String!

  """
  returns permission information for the current user in this course
  """
  permissions: CoursePermissions

  """
  A course-specific post policy
  """
  postPolicy: PostPolicy
  sectionsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): SectionConnection
  state: CourseWorkflowState!

  """
  all the submissions for assignments in this course
  """
  submissionsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionFilterInput

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
    orderBy: [SubmissionOrderCriteria!]

    """
    Only return submissions for the given students.
    """
    studentIds: [ID!]
  ): SubmissionConnection
  term: Term
  updatedAt: DateTime
  usersConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: CourseUsersFilter

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Only include users with the given ids.

    **This field is deprecated, use `filter: {userIds}` instead.**
    """
    userIds: [ID!]
  ): UserConnection
}

"""
The connection type for Course.
"""
type CourseConnection {
  """
  A list of edges.
  """
  edges: [CourseEdge]

  """
  A list of nodes.
  """
  nodes: [Course]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type CourseEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Course
}

"""
Users in a course can be returned based on these enrollment states
"""
enum CourseFilterableEnrollmentState {
  active
  completed
  creation_pending
  inactive
  invited
  rejected
}

type CoursePermissions {
  becomeUser: Boolean
  manageGrades: Boolean
  sendMessages: Boolean
  viewAllGrades: Boolean
  viewAnalytics: Boolean
}

input CourseUsersFilter {
  """
  only return users with the given enrollment state. defaults
  to `invited`, `creation_pending`, `active`
  """
  enrollmentStates: [CourseFilterableEnrollmentState!]

  """
  only include users with the given ids
  """
  userIds: [ID!]
}

"""
States that Courses can be in
"""
enum CourseWorkflowState {
  available
  claimed
  completed
  created
  deleted
}

"""
Autogenerated input type of CreateAssignment
"""
input CreateAssignmentInput {
  allowedAttempts: Int
  allowedExtensions: [String!]

  """
  requires anonymous_marking course feature to be set to true
  """
  anonymousGrading: Boolean
  anonymousInstructorAnnotations: Boolean
  assignmentGroupId: ID
  assignmentOverrides: [AssignmentOverrideCreateOrUpdate!]
  courseId: ID!
  description: String
  dueAt: DateTime
  gradeGroupStudentsIndividually: Boolean
  gradingType: GradingType
  groupSetId: ID
  lockAt: DateTime
  moderatedGrading: AssignmentModeratedGradingUpdate
  moduleIds: [ID!]
  muted: Boolean
  name: String!
  omitFromFinalGrade: Boolean
  onlyVisibleToOverrides: Boolean
  peerReviews: AssignmentPeerReviewsUpdate
  pointsPossible: Float
  position: Int
  postToSis: Boolean
  state: AssignmentState
  submissionTypes: [SubmissionType!]
  unlockAt: DateTime
}

"""
Autogenerated return type of CreateAssignment
"""
type CreateAssignmentPayload {
  assignment: Assignment
  errors: [ValidationError!]
}

"""
Autogenerated input type of CreateGroupInSet
"""
input CreateGroupInSetInput {
  groupSetId: ID!
  name: String!
}

"""
Autogenerated return type of CreateGroupInSet
"""
type CreateGroupInSetPayload {
  errors: [ValidationError!]
  group: Group
}

"""
Autogenerated input type of CreateModule
"""
input CreateModuleInput {
  courseId: ID!
  name: String!
}

"""
Autogenerated return type of CreateModule
"""
type CreateModulePayload {
  errors: [ValidationError!]
  module: Module
}

"""
Autogenerated input type of CreateSubmissionComment
"""
input CreateSubmissionCommentInput {
  attempt: Int
  comment: String!
  fileIds: [ID!]
  mediaObjectId: ID
  submissionId: ID!
}

"""
Autogenerated return type of CreateSubmissionComment
"""
type CreateSubmissionCommentPayload {
  errors: [ValidationError!]
  submissionComment: SubmissionComment
}

"""
Autogenerated input type of CreateSubmissionDraft
"""
input CreateSubmissionDraftInput {
  activeSubmissionType: DraftableSubmissionType!
  attempt: Int
  body: String
  fileIds: [ID!]
  mediaId: ID
  submissionId: ID!
  url: String
}

"""
Autogenerated return type of CreateSubmissionDraft
"""
type CreateSubmissionDraftPayload {
  errors: [ValidationError!]
  submissionDraft: SubmissionDraft
}

"""
Autogenerated input type of CreateSubmission
"""
input CreateSubmissionInput {
  assignmentId: ID!
  body: String
  fileIds: [ID!]
  mediaId: ID
  submissionType: OnlineSubmissionType!
  url: String
}

"""
Autogenerated return type of CreateSubmission
"""
type CreateSubmissionPayload {
  errors: [ValidationError!]
  submission: Submission
}

"""
an ISO8601 formatted time string
"""
scalar DateTime

type Discussion implements LegacyIDInterface & ModuleItemInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  modules: [Module!]
  updatedAt: DateTime
}

"""
Types of submissions that can have a submission draft
"""
enum DraftableSubmissionType {
  media_recording
  online_text_entry
  online_upload
  online_url
}

type Enrollment implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  course: Course
  createdAt: DateTime
  grades(
    """
    The grading period to return grades for. If not specified, will use the
    current grading period (or the course grade for courses that don't use
    grading periods)
    """
    gradingPeriodId: ID
  ): Grades
  id: ID!
  lastActivityAt: DateTime
  section: Section
  state: EnrollmentWorkflowState!
  type: EnrollmentType!
  updatedAt: DateTime
  user: User
}

enum EnrollmentType {
  DesignerEnrollment
  ObserverEnrollment
  StudentEnrollment
  StudentViewEnrollment
  TaEnrollment
  TeacherEnrollment
}

enum EnrollmentWorkflowState {
  active
  completed
  creation_pending
  deleted
  inactive
  invited
  rejected
}

type ExternalTool implements LegacyIDInterface & ModuleItemInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  description: String
  modules: [Module!]
  name: String
  settings: ExternalToolSettings
  state: ExternalToolState
  updatedAt: DateTime
  url: URL
}

"""
The connection type for ExternalTool.
"""
type ExternalToolConnection {
  """
  A list of edges.
  """
  edges: [ExternalToolEdge]

  """
  A list of nodes.
  """
  nodes: [ExternalTool]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type ExternalToolEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: ExternalTool
}

input ExternalToolFilterInput {
  placement: ExternalToolPlacement = null
  state: ExternalToolState = null
}

"""
Placements that an External Tool can have
"""
enum ExternalToolPlacement {
  homework_submission
}

type ExternalToolPlacements {
  canvasIconClass: String
  iconUrl: URL
  messageType: String
  text: String
  url: URL
}

type ExternalToolSettings {
  homeworkSubmission: ExternalToolPlacements
  iconUrl: URL
  selectionHeight: Int
  selectionWidth: Int
  text: String
}

"""
States that an External Tool can be in
"""
enum ExternalToolState {
  anonymous
  email_only
  name_only
  public
}

type ExternalUrl implements LegacyIDInterface & ModuleItemInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  modules: [Module!]
  title: String
  updatedAt: DateTime
  url: String
}

type File implements LegacyIDInterface & ModuleItemInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  contentType: String
  createdAt: DateTime
  displayName: String
  id: ID!
  mimeClass: String
  modules: [Module!]
  submissionPreviewUrl(submissionId: ID!): URL
  thumbnailUrl: URL
  updatedAt: DateTime
  url: URL
}

enum GradeState {
  active
  deleted
}

"""
Contains grade information for a course or grading period
"""
type Grades {
  assignmentGroup: AssignmentGroup
  currentGrade: String

  """
  The current score includes all graded assignments, excluding muted submissions.
  """
  currentScore: Float
  enrollment: Enrollment
  finalGrade: String

  """
  The final score includes all assignments, excluding muted submissions
  (ungraded assignments are counted as 0 points).
  """
  finalScore: Float
  gradingPeriod: GradingPeriod

  """
  The override grade. Supersedes the computed final grade if set.
  """
  overrideGrade: String

  """
  The override score. Supersedes the computed final score if set.
  """
  overrideScore: Float
  state: GradeState!
  unpostedCurrentGrade: String

  """
  The current score includes all graded assignments, including muted submissions.
  """
  unpostedCurrentScore: Float
  unpostedFinalGrade: String

  """
  The final score includes all assignments, including muted submissions
  (ungraded assignments are counted as 0 points).
  """
  unpostedFinalScore: Float
}

"""
The connection type for Grades.
"""
type GradesConnection {
  """
  A list of edges.
  """
  edges: [GradesEdge]

  """
  A list of nodes.
  """
  nodes: [Grades]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type GradesEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Grades
}

type GradingPeriod implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!

  """
      assignments can only be graded before the grading period closes
  """
  closeDate: DateTime
  createdAt: DateTime
  endDate: DateTime
  id: ID!
  startDate: DateTime
  title: String
  updatedAt: DateTime

  """
      used to calculate how much the assignments in this grading period
      contribute to the overall grade
  """
  weight: Float
}

"""
The connection type for GradingPeriod.
"""
type GradingPeriodConnection {
  """
  A list of edges.
  """
  edges: [GradingPeriodEdge]

  """
  A list of nodes.
  """
  nodes: [GradingPeriod]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type GradingPeriodEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: GradingPeriod
}

enum GradingType {
  gpa_scale
  letter_grade
  not_graded
  pass_fail
  percent
  points
}

type Group implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  membersConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GroupMembershipConnection
  name: String
  updatedAt: DateTime
}

"""
The connection type for Group.
"""
type GroupConnection {
  """
  A list of edges.
  """
  edges: [GroupEdge]

  """
  A list of nodes.
  """
  nodes: [Group]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type GroupEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Group
}

type GroupMembership implements LegacyIDInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  state: GroupMembershipState!
  updatedAt: DateTime
  user: User
}

"""
The connection type for GroupMembership.
"""
type GroupMembershipConnection {
  """
  A list of edges.
  """
  edges: [GroupMembershipEdge]

  """
  A list of nodes.
  """
  nodes: [GroupMembership]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type GroupMembershipEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: GroupMembership
}

enum GroupMembershipState {
  accepted
  deleted
  invited
  rejected
  requested
}

type GroupSet implements LegacyIDInterface & Node {
  """
  legacy canvas id
  """
  _id: ID!
  autoLeader: AutoLeaderPolicy
  groupsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): GroupConnection
  id: ID!

  """
  Sets a cap on the number of members in the group.  Only applies when
  self-signup is enabled.
  """
  memberLimit: Int
  name: String
  selfSignup: SelfSignupPolicy!
}

"""
The connection type for GroupSet.
"""
type GroupSetConnection {
  """
  A list of edges.
  """
  edges: [GroupSetEdge]

  """
  A list of nodes.
  """
  nodes: [GroupSet]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type GroupSetEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: GroupSet
}

"""
Autogenerated input type of HideAssignmentGradesForSections
"""
input HideAssignmentGradesForSectionsInput {
  assignmentId: ID!
  sectionIds: [ID!]!
}

"""
Autogenerated return type of HideAssignmentGradesForSections
"""
type HideAssignmentGradesForSectionsPayload {
  assignment: Assignment
  errors: [ValidationError!]
  progress: Progress
  sections: [Section!]
}

"""
Autogenerated input type of HideAssignmentGrades
"""
input HideAssignmentGradesInput {
  assignmentId: ID!
  onlyStudentIds: [ID!]
  sectionIds: [ID!]
  skipStudentIds: [ID!]
}

"""
Autogenerated return type of HideAssignmentGrades
"""
type HideAssignmentGradesPayload {
  assignment: Assignment
  errors: [ValidationError!]
  progress: Progress
  sections: [Section!]
}

"""
Represents untyped JSON
"""
scalar JSON

enum LatePolicyStatusType {
  late
  missing
  none
}

interface LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
}

type LockInfo {
  canView: Boolean
  isLocked: Boolean!
  lockAt: DateTime
  lockedObject: Lockable
  module: Module
  unlockAt: DateTime
}

"""
Types that can be locked
"""
union Lockable = Assignment | Discussion | Module | Page | Quiz

"""
Autogenerated input type of MarkSubmissionCommentsRead
"""
input MarkSubmissionCommentsReadInput {
  submissionCommentIds: [ID!]!
  submissionId: ID!
}

"""
Autogenerated return type of MarkSubmissionCommentsRead
"""
type MarkSubmissionCommentsReadPayload {
  errors: [ValidationError!]
  submissionComments: [SubmissionComment!]
}

type MediaObject implements Node {
  """
  legacy canvas id
  """
  _id: ID!
  canAddCaptions: Boolean
  id: ID!
  mediaSources: [MediaSource!]
  mediaTracks: [MediaTrack!]
  mediaType: MediaType
  title: String
}

type MediaSource {
  bitrate: String
  contentType: String
  fileExt: String
  height: String
  isOriginal: String
  size: String
  url: URL
  width: String
}

type MediaTrack implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  content: String!
  kind: String
  locale: String
  mediaObject: MediaObject
  webvttContent: String
}

enum MediaType {
  audio
  video
}

"""
Settings for Moderated Grading on an Assignment
"""
type ModeratedGrading {
  """
  Boolean indicating if the assignment is moderated.
  """
  enabled: Boolean

  """
  The user of the grader responsible for choosing final grades for this assignment.
  """
  finalGrader: User

  """
  Boolean indicating if provisional graders' comments are visible to other provisional graders.
  """
  graderCommentsVisibleToGraders: Boolean

  """
  The maximum number of provisional graders who may issue grades for this assignment.
  """
  graderCount: Int

  """
  Boolean indicating if provisional graders' identities are hidden from other provisional graders.
  """
  graderNamesVisibleToFinalGrader: Boolean

  """
  Boolean indicating if provisional grader identities are visible to the final grader.
  """
  gradersAnonymousToGraders: Boolean
}

type Module implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  moduleItems: [ModuleItem!]
  name: String
  position: Int
  unlockAt: DateTime
  updatedAt: DateTime
}

"""
The connection type for Module.
"""
type ModuleConnection {
  """
  A list of edges.
  """
  edges: [ModuleEdge]

  """
  A list of nodes.
  """
  nodes: [Module]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type ModuleEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Module
}

type ModuleExternalTool implements LegacyIDInterface & ModuleItemInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  modules: [Module!]
  updatedAt: DateTime
  url: String
}

type ModuleItem implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  content: ModuleItemInterface
  createdAt: DateTime
  id: ID!
  module: Module
  next: ModuleItem
  previous: ModuleItem
  updatedAt: DateTime
  url: URL
}

"""
An item that can be in context modules
"""
interface ModuleItemInterface {
  modules: [Module!]
}

type Mutation {
  createAssignment(input: CreateAssignmentInput!): CreateAssignmentPayload
  createGroupInSet(input: CreateGroupInSetInput!): CreateGroupInSetPayload
  createModule(input: CreateModuleInput!): CreateModulePayload

  """
  IN ACTIVE DEVELOPMENT, USE AT YOUR OWN RISK: Submit homework on an assignment.
  """
  createSubmission(input: CreateSubmissionInput!): CreateSubmissionPayload
  createSubmissionComment(input: CreateSubmissionCommentInput!): CreateSubmissionCommentPayload
  createSubmissionDraft(input: CreateSubmissionDraftInput!): CreateSubmissionDraftPayload
  hideAssignmentGrades(input: HideAssignmentGradesInput!): HideAssignmentGradesPayload
  hideAssignmentGradesForSections(input: HideAssignmentGradesForSectionsInput!): HideAssignmentGradesForSectionsPayload
  markSubmissionCommentsRead(input: MarkSubmissionCommentsReadInput!): MarkSubmissionCommentsReadPayload
  postAssignmentGrades(input: PostAssignmentGradesInput!): PostAssignmentGradesPayload
  postAssignmentGradesForSections(input: PostAssignmentGradesForSectionsInput!): PostAssignmentGradesForSectionsPayload

  """
  Sets the post policy for the assignment.
  """
  setAssignmentPostPolicy(input: SetAssignmentPostPolicyInput!): SetAssignmentPostPolicyPayload

  """
  Sets the post policy for the course, with an option to override and delete
  existing assignment post policies.
  """
  setCoursePostPolicy(input: SetCoursePostPolicyInput!): SetCoursePostPolicyPayload

  """
  Sets the overridden final score for the associated enrollment, optionally limited to a specific
  grading period. This will supersede the computed final score/grade if present.
  """
  setOverrideScore(input: SetOverrideScoreInput!): SetOverrideScorePayload
  updateAssignment(input: UpdateAssignmentInput!): UpdateAssignmentPayload
}

type MutationLog {
  assetString: ID!
  mutationId: ID!
  mutationName: String!
  params: JSON

  """
  If the mutation was performed by a user masquerading as another user,
  this field returns the "real" (logged-in) user.
  """
  realUser: User
  timestamp: DateTime
  user: User
}

"""
The connection type for MutationLog.
"""
type MutationLogConnection {
  """
  A list of edges.
  """
  edges: [MutationLogEdge]

  """
  A list of nodes.
  """
  nodes: [MutationLog]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type MutationLogEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: MutationLog
}

"""
An object with an ID.
"""
interface Node {
  """
  ID of the object.
  """
  id: ID!
}

enum NodeType {
  Account
  Assignment
  AssignmentGroup
  Course
  Discussion
  Enrollment
  File
  GradingPeriod
  Group
  GroupSet
  MediaObject
  Module
  ModuleItem
  Page
  PostPolicy
  Progress
  Rubric
  Section
  Submission
  Term
  User
}

"""
Types that can be submitted online
"""
enum OnlineSubmissionType {
  media_recording
  online_text_entry
  online_upload
  online_url
}

enum OrderDirection {
  ascending
  descending
}

type Outcome implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
}

type Page implements LegacyIDInterface & ModuleItemInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  modules: [Module!]
  title: String
  updatedAt: DateTime
}

"""
Information about pagination in a connection.
"""
type PageInfo {
  """
  When paginating forwards, the cursor to continue.
  """
  endCursor: String

  """
  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: String
}

type PageViewAnalysis {
  """
  This number (0-3) is intended to give an idea of how the student is doing relative to others in the course
  """
  level: Int

  """
  The maximum number of views/participations in this course
  """
  max: Int

  """
  The number of views/participations this student has
  """
  total: Int
}

"""
Settings for Peer Reviews on an Assignment
"""
type PeerReviews {
  """
  Boolean representing whether or not peer reviews are anonymous
  """
  anonymousReviews: Boolean

  """
  Boolean indicating peer reviews are assigned automatically. If false, the
  teacher is expected to manually assign peer reviews.
  """
  automaticReviews: Boolean

  """
  Integer representing the amount of reviews each user is assigned.
  """
  count: Int

  """
  Date and Time representing when the peer reviews are due
  """
  dueAt: DateTime

  """
  Boolean indicating if peer reviews are required for this assignment
  """
  enabled: Boolean

  """
  Boolean representing whether or not members from within the same group on a
  group assignment can be assigned to peer review their own group's work
  """
  intraReviews: Boolean
}

"""
Autogenerated input type of PostAssignmentGradesForSections
"""
input PostAssignmentGradesForSectionsInput {
  assignmentId: ID!
  gradedOnly: Boolean
  sectionIds: [ID!]!
}

"""
Autogenerated return type of PostAssignmentGradesForSections
"""
type PostAssignmentGradesForSectionsPayload {
  assignment: Assignment
  errors: [ValidationError!]
  progress: Progress
  sections: [Section!]
}

"""
Autogenerated input type of PostAssignmentGrades
"""
input PostAssignmentGradesInput {
  assignmentId: ID!
  gradedOnly: Boolean
  onlyStudentIds: [ID!]
  sectionIds: [ID!]
  skipStudentIds: [ID!]
}

"""
Autogenerated return type of PostAssignmentGrades
"""
type PostAssignmentGradesPayload {
  assignment: Assignment
  errors: [ValidationError!]
  progress: Progress
  sections: [Section!]
}

"""
A PostPolicy sets the policy for whether a Submission's grades are posted
automatically or manually. A PostPolicy can be set at the Course and/or
Assignment level.
"""
type PostPolicy implements LegacyIDInterface & Node {
  """
  legacy canvas id
  """
  _id: ID!
  assignment: Assignment
  course: Course!

  """
  ID of the object.
  """
  id: ID!
  postManually: Boolean!
}

"""
The connection type for PostPolicy.
"""
type PostPolicyConnection {
  """
  A list of edges.
  """
  edges: [PostPolicyEdge]

  """
  A list of nodes.
  """
  nodes: [PostPolicy]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type PostPolicyEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: PostPolicy
}

"""
Customized proficiency ratings
"""
type ProficiencyRating implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  color: String
  description: String
  mastery: Boolean!
  points: Float
}

"""
The connection type for ProficiencyRating.
"""
type ProficiencyRatingConnection {
  """
  A list of edges.
  """
  edges: [ProficiencyRatingEdge]

  """
  A list of nodes.
  """
  nodes: [ProficiencyRating]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type ProficiencyRatingEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: ProficiencyRating
}

"""
Returns completion status and progress information about an asynchronous job
"""
type Progress implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!

  """
  percent completed
  """
  completion: Int
  context: ProgressContext
  createdAt: DateTime
  id: ID!

  """
  details about the job
  """
  message: String
  state: ProgressState!

  """
  the type of operation
  """
  tag: String!
  updatedAt: DateTime
}

union ProgressContext = Assignment | Course | File | GroupSet | User

enum ProgressState {
  completed
  failed
  queued
  running
}

type Query {
  account(
    """
    a graphql or legacy id
    """
    id: ID!
  ): Account

  """
  All courses viewable by the current user
  """
  allCourses: [Course!]
  assignment(
    """
    a graphql or legacy id
    """
    id: ID!
  ): Assignment
  assignmentGroup(
    """
    a graphql or legacy id
    """
    id: ID!
  ): AssignmentGroup
  auditLogs: AuditLogs
  course(
    """
    a graphql or legacy id
    """
    id: ID!
  ): Course

  """
  Fetches an object given its type and legacy ID
  """
  legacyNode(_id: ID!, type: NodeType!): Node

  """
  ModuleItem
  """
  moduleItem(
    """
    a graphql or legacy id
    """
    id: ID!
  ): ModuleItem

  """
  Fetches an object given its ID.
  """
  node(
    """
    ID of the object.
    """
    id: ID!
  ): Node
  submission(
    """
    a graphql or legacy id
    """
    id: ID!
  ): Submission
  term(
    """
    a graphql or legacy id
    """
    id: ID!
  ): Term
}

type Quiz implements LegacyIDInterface & ModuleItemInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  modules: [Module!]
  updatedAt: DateTime
}

type Rubric implements LegacyIDInterface & Node {
  """
  legacy canvas id
  """
  _id: ID!

  """
  The different criteria that makes up this rubric
  """
  criteria: [RubricCriterion!]!
  freeFormCriterionComments: Boolean!
  hideScoreTotal: Boolean!
  id: ID!
  pointsPossible: Float
  title: String
}

"""
An assessment for a rubric
"""
type RubricAssessment implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!

  """
  The assessments for the individual criteria in this rubric
  """
  assessmentRatings: [RubricAssessmentRating!]!
  assessmentType: AssessmentType!
  assessor: User
  rubricAssociation: RubricAssociation
  score: Float
  user: User
}

"""
The connection type for RubricAssessment.
"""
type RubricAssessmentConnection {
  """
  A list of edges.
  """
  edges: [RubricAssessmentEdge]

  """
  A list of nodes.
  """
  nodes: [RubricAssessment]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type RubricAssessmentEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: RubricAssessment
}

"""
An assessment for a specific criteria in a rubric
"""
type RubricAssessmentRating {
  """
  legacy canvas id
  """
  _id: ID
  comments: String
  commentsHtml: String

  """
  The rubric criteria that this assessment is for
  """
  criterion: RubricCriterion
  description: String
  outcome: Outcome
  points: Float
}

"""
How a rubric is being used in a context
"""
type RubricAssociation implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  hidePoints: Boolean!
  hideScoreTotal: Boolean!
  useForGrading: Boolean!
}

"""
Individual criteria for a rubric
"""
type RubricCriterion implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  criterionUseRange: Boolean!
  description: String
  ignoreForScoring: Boolean!
  longDescription: String
  masteryPoints: Float
  outcome: Outcome
  points: Float

  """
  The possible ratings available for this criterion
  """
  ratings: [RubricRating!]
}

"""
Possible rating for a rubric criterion
"""
type RubricRating implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  description: String!
  longDescription: String
  points: Float!
}

type Section implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  createdAt: DateTime
  id: ID!
  name: String!
  updatedAt: DateTime
}

"""
The connection type for Section.
"""
type SectionConnection {
  """
  A list of edges.
  """
  edges: [SectionEdge]

  """
  A list of nodes.
  """
  nodes: [Section]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type SectionEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Section
}

"""
Determines if/how a student may join a group. A student can belong to
only one group per group set at a time.
"""
enum SelfSignupPolicy {
  """
  self signup is not allowed
  """
  disabled

  """
  students may join any group
  """
  enabled

  """
  students may join a group in their section
  """
  restricted
}

"""
Autogenerated input type of SetAssignmentPostPolicy
"""
input SetAssignmentPostPolicyInput {
  assignmentId: ID!
  postManually: Boolean!
}

"""
Autogenerated return type of SetAssignmentPostPolicy
"""
type SetAssignmentPostPolicyPayload {
  errors: [ValidationError!]
  postPolicy: PostPolicy
}

"""
Autogenerated input type of SetCoursePostPolicy
"""
input SetCoursePostPolicyInput {
  courseId: ID!
  postManually: Boolean!
}

"""
Autogenerated return type of SetCoursePostPolicy
"""
type SetCoursePostPolicyPayload {
  errors: [ValidationError!]
  postPolicy: PostPolicy
}

"""
Autogenerated input type of SetOverrideScore
"""
input SetOverrideScoreInput {
  enrollmentId: ID!
  gradingPeriodId: ID
  overrideScore: Float
}

"""
Autogenerated return type of SetOverrideScore
"""
type SetOverrideScorePayload {
  errors: [ValidationError!]
  grades: Grades
}

"""
basic information about a students activity in a course
"""
type StudentSummaryAnalytics {
  pageViews: PageViewAnalysis
  participations: PageViewAnalysis
  tardinessBreakdown: TardinessBreakdown
}

type SubHeader implements ModuleItemInterface {
  modules: [Module!]
  title: String
}

type Submission implements LegacyIDInterface & Node & SubmissionInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  assignment: Assignment
  attachment: File
  attachments: [File!]
  attempt: Int!
  body: String
  commentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionCommentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): SubmissionCommentConnection
  createdAt: DateTime

  """
  how many points are being deducted due to late policy
  """
  deductedPoints: Float

  """
  the submission grade *before* late policy deductions were applied
  """
  enteredGrade: String

  """
  the submission score *before* late policy deductions were applied
  """
  enteredScore: Float

  """
  excused assignments are ignored when calculating grades
  """
  excused: Boolean
  grade: String
  gradeHidden: Boolean!

  """
  was the grade given on the current submission (resubmission)
  """
  gradeMatchesCurrentSubmission: Boolean
  gradedAt: DateTime
  gradingStatus: SubmissionGradingStatus
  id: ID!
  late: Boolean
  latePolicyStatus: LatePolicyStatusType
  mediaObject: MediaObject
  missing: Boolean
  posted: Boolean!
  postedAt: DateTime
  rubricAssessmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionRubricAssessmentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): RubricAssessmentConnection
  score: Float
  state: SubmissionState!
  submissionDraft: SubmissionDraft
  submissionHistoriesConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionHistoryFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): SubmissionHistoryConnection
  submissionStatus: String
  submissionType: SubmissionType
  submittedAt: DateTime
  turnitinData: [TurnitinData!]
  unreadCommentCount: Int!
  updatedAt: DateTime
  url: URL
  user: User
}

type SubmissionComment implements LegacyIDInterface & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  attachments: [File!]
  attempt: Int!
  author: User
  comment: String
  createdAt: DateTime
  mediaObject: MediaObject
  read: Boolean!
  updatedAt: DateTime
}

"""
The connection type for SubmissionComment.
"""
type SubmissionCommentConnection {
  """
  A list of edges.
  """
  edges: [SubmissionCommentEdge]

  """
  A list of nodes.
  """
  nodes: [SubmissionComment]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type SubmissionCommentEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: SubmissionComment
}

input SubmissionCommentFilterInput {
  """
  If all of the comments, regardless of the submission attempt, should be returned.
  If this is true, the for_attempt argument will be ignored.
  """
  allComments: Boolean = false

  """
  What submission attempt the comments should be returned for. If not specified,
  it will return the comments for the current submisssion or submission history.
  """
  forAttempt: Int = null
}

"""
The connection type for Submission.
"""
type SubmissionConnection {
  """
  A list of edges.
  """
  edges: [SubmissionEdge]

  """
  A list of nodes.
  """
  nodes: [Submission]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

type SubmissionDraft implements LegacyIDInterface {
  """
  legacy canvas id
  """
  _id: ID!
  activeSubmissionType: DraftableSubmissionType
  attachments: [File!]
  body: String
  mediaObject: MediaObject
  meetsAssignmentCriteria: Boolean!
  meetsMediaRecordingCriteria: Boolean!
  meetsTextEntryCriteria: Boolean!
  meetsUploadCriteria: Boolean!
  meetsUrlCriteria: Boolean!
  submissionAttempt: Int!
  url: URL
}

"""
An edge in a connection.
"""
type SubmissionEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: Submission
}

input SubmissionFilterInput {
  gradedSince: DateTime
  sectionIds: [ID!]
  states: [SubmissionState!] = [submitted, pending_review, graded]
  submittedSince: DateTime
}

enum SubmissionGradingStatus {
  excused
  graded
  needs_grading
  needs_review
}

type SubmissionHistory implements SubmissionInterface & Timestamped {
  assignment: Assignment
  attachment: File
  attachments: [File!]
  attempt: Int!
  body: String
  commentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionCommentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): SubmissionCommentConnection
  createdAt: DateTime

  """
  how many points are being deducted due to late policy
  """
  deductedPoints: Float

  """
  the submission grade *before* late policy deductions were applied
  """
  enteredGrade: String

  """
  the submission score *before* late policy deductions were applied
  """
  enteredScore: Float

  """
  excused assignments are ignored when calculating grades
  """
  excused: Boolean
  grade: String
  gradeHidden: Boolean!

  """
  was the grade given on the current submission (resubmission)
  """
  gradeMatchesCurrentSubmission: Boolean
  gradedAt: DateTime
  gradingStatus: SubmissionGradingStatus
  late: Boolean
  latePolicyStatus: LatePolicyStatusType
  mediaObject: MediaObject
  missing: Boolean
  posted: Boolean!
  postedAt: DateTime

  """
  The canvas legacy id of the root submission this history belongs to
  """
  rootId: ID!
  rubricAssessmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionRubricAssessmentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): RubricAssessmentConnection
  score: Float
  state: SubmissionState!
  submissionDraft: SubmissionDraft
  submissionStatus: String
  submissionType: SubmissionType
  submittedAt: DateTime
  turnitinData: [TurnitinData!]
  unreadCommentCount: Int!
  updatedAt: DateTime
  url: URL
  user: User
}

"""
The connection type for SubmissionHistory.
"""
type SubmissionHistoryConnection {
  """
  A list of edges.
  """
  edges: [SubmissionHistoryEdge]

  """
  A list of nodes.
  """
  nodes: [SubmissionHistory]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type SubmissionHistoryEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: SubmissionHistory
}

input SubmissionHistoryFilterInput {
  """
  If the most current submission should be included in the submission
  history results. Defaults to true.
  """
  includeCurrentSubmission: Boolean = true
  states: [SubmissionState!] = [deleted, graded, pending_review, submitted, ungraded, unsubmitted]
}

"""
Types for submission or submission history
"""
interface SubmissionInterface {
  assignment: Assignment
  attachment: File
  attachments: [File!]
  attempt: Int!
  body: String
  commentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionCommentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): SubmissionCommentConnection

  """
  how many points are being deducted due to late policy
  """
  deductedPoints: Float

  """
  the submission grade *before* late policy deductions were applied
  """
  enteredGrade: String

  """
  the submission score *before* late policy deductions were applied
  """
  enteredScore: Float

  """
  excused assignments are ignored when calculating grades
  """
  excused: Boolean
  grade: String
  gradeHidden: Boolean!

  """
  was the grade given on the current submission (resubmission)
  """
  gradeMatchesCurrentSubmission: Boolean
  gradedAt: DateTime
  gradingStatus: SubmissionGradingStatus
  late: Boolean
  latePolicyStatus: LatePolicyStatusType
  mediaObject: MediaObject
  missing: Boolean
  posted: Boolean!
  postedAt: DateTime
  rubricAssessmentsConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String
    filter: SubmissionRubricAssessmentFilterInput = {}

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): RubricAssessmentConnection
  score: Float
  state: SubmissionState!
  submissionDraft: SubmissionDraft
  submissionStatus: String
  submissionType: SubmissionType
  submittedAt: DateTime
  turnitinData: [TurnitinData!]
  unreadCommentCount: Int!
  url: URL
  user: User
}

input SubmissionOrderCriteria {
  direction: OrderDirection
  field: SubmissionOrderField!
}

enum SubmissionOrderField {
  _id
  gradedAt
}

input SubmissionRubricAssessmentFilterInput {
  """
  What submission attempt the rubric assessment should be returned for. If not
  specified, it will return the rubric assessment for the current submisssion
  or submission history.
  """
  forAttempt: Int = null
}

input SubmissionSearchFilterInput {
  enrollmentTypes: [EnrollmentType!]

  """
  Limit results by grading status
  """
  gradingStatus: SubmissionGradingStatus

  """
  Limit results to submissions that are late
  """
  late: Boolean

  """
  Limit results to submissions that scored below the specified value
  """
  scoredLessThan: Float

  """
  Limit results to submissions that scored above the specified value
  """
  scoredMoreThan: Float
  sectionIds: [ID!]
  states: [SubmissionState!] = [submitted, pending_review, graded]

  """
  The partial name or full ID of the users to match and return in the
  results list. Must be at least 3 characters.
  Queries by administrative users will search on SIS ID, login ID, name, or email
  address; non-administrative queries will only be compared against name.
  """
  userSearch: String
}

"""
Specify a sort for the results
"""
input SubmissionSearchOrder {
  direction: OrderDirection
  field: SubmissionSearchOrderField!
}

"""
The user or submission field to sort by
"""
enum SubmissionSearchOrderField {
  score
  submitted_at
  username
}

enum SubmissionState {
  deleted
  graded
  pending_review
  submitted
  ungraded
  unsubmitted
}

"""
Types of submissions an assignment accepts
"""
enum SubmissionType {
  attendance
  discussion_topic
  external_tool
  media_recording
  none
  not_graded
  on_paper
  online_quiz
  online_text_entry
  online_upload
  online_url
  wiki_page
}

"""
statistics based on timeliness of student submissions
"""
type TardinessBreakdown {
  late: Float
  missing: Float
  onTime: Float
  total: Int
}

type Term implements LegacyIDInterface & Node {
  """
  legacy canvas id
  """
  _id: ID!

  """
  courses for this term
  """
  coursesConnection(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: String

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: String

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the last _n_ elements from the list.
    """
    last: Int
  ): CourseConnection
  endAt: DateTime
  id: ID!
  name: String
  sisTermId: ID
  startAt: DateTime
}

"""
Contains timestamp metadata
"""
interface Timestamped {
  createdAt: DateTime
  updatedAt: DateTime
}

union TurnitinContext = File | Submission

type TurnitinData {
  score: Float
  status: String
  target: TurnitinContext!
}

scalar URL

"""
Autogenerated input type of UpdateAssignment
"""
input UpdateAssignmentInput {
  allowedAttempts: Int
  allowedExtensions: [String!]

  """
  requires anonymous_marking course feature to be set to true
  """
  anonymousGrading: Boolean
  anonymousInstructorAnnotations: Boolean
  assignmentGroupId: ID
  assignmentOverrides: [AssignmentOverrideCreateOrUpdate!]
  description: String
  dueAt: DateTime
  gradeGroupStudentsIndividually: Boolean
  gradingType: GradingType
  groupSetId: ID
  id: ID!
  lockAt: DateTime
  moderatedGrading: AssignmentModeratedGradingUpdate
  moduleIds: [ID!]
  muted: Boolean
  name: String
  omitFromFinalGrade: Boolean
  onlyVisibleToOverrides: Boolean
  peerReviews: AssignmentPeerReviewsUpdate
  pointsPossible: Float
  position: Int
  postToSis: Boolean
  state: AssignmentState
  submissionTypes: [SubmissionType!]
  unlockAt: DateTime
}

"""
Autogenerated return type of UpdateAssignment
"""
type UpdateAssignmentPayload {
  assignment: Assignment
  errors: [ValidationError!]
}

type User implements LegacyIDInterface & Node & Timestamped {
  """
  legacy canvas id
  """
  _id: ID!
  avatarUrl: URL
  createdAt: DateTime
  email: String
  enrollments(
    """
    only return enrollments for this course
    """
    courseId: ID
  ): [Enrollment!]!
  groups: [Group!]
  id: ID!
  name: String
  pronoun: String

  """
  A short name the user has selected, for use in conversations or other less formal places through the site.
  """
  shortName: String

  """
  The name of the user that is should be used for sorting groups of users, such as in the gradebook.
  """
  sortableName: String
  summaryAnalytics(
    """
    returns summary analytics for this course
    """
    courseId: ID!
  ): StudentSummaryAnalytics
  updatedAt: DateTime
}

"""
The connection type for User.
"""
type UserConnection {
  """
  A list of edges.
  """
  edges: [UserEdge]

  """
  A list of nodes.
  """
  nodes: [User]

  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
}

"""
An edge in a connection.
"""
type UserEdge {
  """
  A cursor for use in pagination.
  """
  cursor: String!

  """
  The item at the end of the edge.
  """
  node: User
}

type ValidationError {
  attribute: String
  message: String!
}