nixpkgs / pkgs / development / tools / rover / schema / schema.graphql

schema {
  query: Query
  mutation: Mutation
}

"""An organization in Apollo Studio. Can have multiple members and graphs."""
type Organization {
  auditLogExports: [AuditLogExport!]
  """Graphs belonging to this organization."""
  graphs(includeDeleted: Boolean): [Graph!]!
  """Globally unique identifier, which isn't guaranteed stable (can be changed by administrators)."""
  id: ID!
  """Name of the organization, which can change over time and isn't unique."""
  name: String!
  """Graphs belonging to this organization."""
  services(includeDeleted: Boolean): [Graph!]! @deprecated(reason: "Use graphs field instead")
}

type OrganizationMutation {
  """Trigger a request for an audit export"""
  requestAuditExport(actors: [ActorInput!], from: Timestamp!, graphIds: [String!], to: Timestamp!): Organization
}

"""Represents an actor that performs actions in Apollo Studio. Most actors are either a `USER` or a `GRAPH` (based on a request's provided API key), and they have the corresponding `ActorType`."""
type Actor {
  actorId: ID!
  type: ActorType!
}

"""Input type to provide when specifying an `Actor` in operation arguments. See also the `Actor` object type."""
input ActorInput {
  actorId: ID!
  type: ActorType!
}

enum ActorType {
  ANONYMOUS_USER
  BACKFILL
  CRON
  GRAPH
  INTERNAL_IDENTITY
  SYNCHRONIZATION
  SYSTEM
  USER
}

union AddOperationCollectionEntriesResult = AddOperationCollectionEntriesSuccess | PermissionError | ValidationError

type AddOperationCollectionEntriesSuccess {
  operationCollectionEntries: [OperationCollectionEntry!]!
}

union AddOperationCollectionEntryResult = OperationCollectionEntry | PermissionError | ValidationError

input AddOperationInput {
  """The operation's fields."""
  document: OperationCollectionEntryStateInput!
  """The operation's name."""
  name: String!
}

type AffectedQuery {
  id: ID!
  """First 128 characters of query signature for display"""
  signature: String
  """Name to display to the user for the operation"""
  displayName: String
  """Name provided for the operation, which can be empty string if it is an anonymous operation"""
  name: String
  """Determines if this query validates against the proposed schema"""
  isValid: Boolean
  """List of changes affecting this query. Returns null if queried from SchemaDiff.changes.affectedQueries.changes"""
  changes: [ChangeOnOperation!]
  """Whether this operation was ignored and its severity was downgraded for that reason"""
  markedAsIgnored: Boolean
  """Whether the changes were marked as safe and its severity was downgraded for that reason"""
  markedAsSafe: Boolean
  """If the operation would be approved if the check ran again. Returns null if queried from SchemaDiff.changes.affectedQueries.alreadyApproved"""
  alreadyApproved: Boolean
  """If the operation would be ignored if the check ran again"""
  alreadyIgnored: Boolean
}

"""
Represents an API key that's used to authenticate a
particular Apollo user or graph.
"""
interface ApiKey {
  """The API key's ID."""
  id: ID!
  """The API key's name, for distinguishing it from other keys."""
  keyName: String
  """The value of the API key. **This is a secret credential!**"""
  token: String!
}

type ApiKeyProvision {
  apiKey: ApiKey!
  created: Boolean!
}

type AuditLogExport {
  """The list of actors to filter the audit export"""
  actors: [Identity!]
  """The time when the audit export was completed"""
  completedAt: Timestamp
  """The time when the audit export was reqeusted"""
  createdAt: Timestamp!
  """List of URLs to download the audits for the requested range"""
  downloadUrls: [String!]
  """The starting point of audits to include in export"""
  from: Timestamp!
  """The list of graphs to filter the audit export"""
  graphs: [Graph!]
  """The id for the audit export"""
  id: ID!
  """The user that initiated the audit export"""
  requester: User
  """The status of the audit export"""
  status: AuditStatus!
  """The end point of audits to include in export"""
  to: Timestamp!
}

enum AuditStatus {
  CANCELLED
  COMPLETED
  EXPIRED
  FAILED
  IN_PROGRESS
  QUEUED
}

"""The building of a Studio variant (including supergraph composition and any contract filtering) as part of a launch."""
type Build {
  """The inputs provided to the build, including subgraph and contract details."""
  input: BuildInput!
  """The result of the build. This value is null until the build completes."""
  result: BuildResult
}

"""A single error that occurred during the failed execution of a build."""
type BuildError {
  code: String
  locations: [SourceLocation!]!
  message: String!
}

"""Contains the details of an executed build that failed."""
type BuildFailure {
  """A list of all errors that occurred during the failed build."""
  errorMessages: [BuildError!]!
}

union BuildInput = CompositionBuildInput | FilterBuildInput

union BuildResult = BuildFailure | BuildSuccess

"""Contains the details of an executed build that succeeded."""
type BuildSuccess {
  """Contains the supergraph and API schemas created by composition."""
  coreSchema: CoreSchema!
}

"""A single change that was made to a definition in a schema."""
type Change {
  """The severity of the change (e.g., `FAILURE` or `NOTICE`)"""
  severity: ChangeSeverity!
  """Indicates the type of change that was made, and to what (e.g., 'TYPE_REMOVED')."""
  code: String!
  """Indication of the category of the change (e.g. addition, removal, edit)."""
  category: ChangeCategory!
  """A human-readable description of the change."""
  description: String!
  affectedQueries: [AffectedQuery!]
  """Top level node affected by the change."""
  parentNode: NamedIntrospectionType
  """
  Node related to the top level node that was changed, such as a field in an object,
  a value in an enum or the object of an interface.
  """
  childNode: NamedIntrospectionValue
  """Target arg of change made."""
  argNode: NamedIntrospectionArg
}

"""
Defines a set of categories that a schema change
can be grouped by.
"""
enum ChangeCategory {
  ADDITION
  EDIT
  REMOVAL
  DEPRECATION
}

"""
These schema change codes represent all of the possible changes that can
occur during the schema diff algorithm.
"""
enum ChangeCode {
  """Field was removed from the type."""
  FIELD_REMOVED
  """Type (object or scalar) was removed from the schema."""
  TYPE_REMOVED
  """Argument to a field was removed."""
  ARG_REMOVED
  """Type is no longer included in the union."""
  TYPE_REMOVED_FROM_UNION
  """Field was removed from the input object."""
  FIELD_REMOVED_FROM_INPUT_OBJECT
  """Value was removed from the enum."""
  VALUE_REMOVED_FROM_ENUM
  """Type no longer implements the interface."""
  TYPE_REMOVED_FROM_INTERFACE
  """Non-nullable argument was added to the field."""
  REQUIRED_ARG_ADDED
  """Non-nullable field was added to the input object. (Deprecated.)"""
  NON_NULLABLE_FIELD_ADDED_TO_INPUT_OBJECT
  """Required field was added to the input object."""
  REQUIRED_FIELD_ADDED_TO_INPUT_OBJECT
  """Return type for the field was changed."""
  FIELD_CHANGED_TYPE
  """Type of the field in the input object was changed."""
  FIELD_ON_INPUT_OBJECT_CHANGED_TYPE
  """
  Type was changed from one kind to another.
  Ex: scalar to object or enum to union.
  """
  TYPE_CHANGED_KIND
  """Type of the argument was changed."""
  ARG_CHANGED_TYPE
  """Argument was changed from nullable to non-nullable."""
  ARG_CHANGED_TYPE_OPTIONAL_TO_REQUIRED
  """A new value was added to the enum."""
  VALUE_ADDED_TO_ENUM
  """A new value was added to the enum."""
  TYPE_ADDED_TO_UNION
  """Type now implements the interface."""
  TYPE_ADDED_TO_INTERFACE
  """Default value added or changed for the argument."""
  ARG_DEFAULT_VALUE_CHANGE
  """Nullable argument was added to the field."""
  OPTIONAL_ARG_ADDED
  """Nullable field was added to the input type. (Deprecated.)"""
  NULLABLE_FIELD_ADDED_TO_INPUT_OBJECT
  """Optional field was added to the input type."""
  OPTIONAL_FIELD_ADDED_TO_INPUT_OBJECT
  """Field was added to the type."""
  FIELD_ADDED
  """Type was added to the schema."""
  TYPE_ADDED
  """Enum was deprecated."""
  ENUM_DEPRECATED
  """Enum deprecation was removed."""
  ENUM_DEPRECATION_REMOVED
  """Reason for enum deprecation changed."""
  ENUM_DEPRECATED_REASON_CHANGE
  """Field was deprecated."""
  FIELD_DEPRECATED
  """Field deprecation removed."""
  FIELD_DEPRECATION_REMOVED
  """Reason for field deprecation changed."""
  FIELD_DEPRECATED_REASON_CHANGE
  """Description was added, removed, or updated for type."""
  TYPE_DESCRIPTION_CHANGE
  """Description was added, removed, or updated for field."""
  FIELD_DESCRIPTION_CHANGE
  """Description was added, removed, or updated for enum value."""
  ENUM_VALUE_DESCRIPTION_CHANGE
  """Description was added, removed, or updated for argument."""
  ARG_DESCRIPTION_CHANGE
  """Directive was removed."""
  DIRECTIVE_REMOVED
  """Argument to the directive was removed."""
  DIRECTIVE_ARG_REMOVED
  """Location of the directive was removed."""
  DIRECTIVE_LOCATION_REMOVED
  """Repeatable flag was removed for directive."""
  DIRECTIVE_REPEATABLE_REMOVED
  """Non-nullable argument added to directive."""
  REQUIRED_DIRECTIVE_ARG_ADDED
}

"""
Represents the tuple of static information
about a particular kind of schema change.
"""
type ChangeDefinition {
  code: ChangeCode!
  defaultSeverity: ChangeSeverity!
  category: ChangeCategory!
}

"""An addition made to a Studio variant's changelog after a launch."""
type ChangelogLaunchResult {
  createdAt: Timestamp!
  schemaTagID: ID!
}

"""Info about a change in the context of an operation it affects"""
type ChangeOnOperation {
  """The semantic info about this change, i.e. info about the change that doesn't depend on the operation"""
  semanticChange: SemanticChange!
  """Human-readable explanation of the impact of this change on the operation"""
  impact: String
}

enum ChangeSeverity {
  FAILURE
  NOTICE
}

"""
Summary of the changes for a schema diff, computed by placing the changes into categories and then
counting the size of each category. This categorization can be done in different ways, and
accordingly there are multiple fields here for each type of categorization.

Note that if an object or interface field is added/removed, there won't be any addition/removal
changes generated for its arguments or @deprecated usages. If an enum type is added/removed, there
will be addition/removal changes generated for its values, but not for those values' @deprecated
usages. Description changes won't be generated for a schema element if that element (or an
ancestor) was added/removed.
"""
type ChangeSummary {
  """
  Counts for changes to non-field aspects of objects, input objects, and interfaces,
  and all aspects of enums, unions, and scalars.
  """
  type: TypeChangeSummaryCounts!
  """Counts for changes to fields of objects, input objects, and interfaces."""
  field: FieldChangeSummaryCounts!
  """Counts for all changes."""
  total: TotalChangeSummaryCounts!
}

enum ChangeType {
  FAILURE
  NOTICE
}

"""Filter options available when listing checks."""
input CheckFilterInput {
  authors: [String!]
  branches: [String!]
  subgraphs: [String!]
  status: CheckFilterInputStatusOption
  variants: [String!]
}

"""Options for filtering CheckWorkflows by status"""
enum CheckFilterInputStatusOption {
  FAILED
  PENDING
  PASSED
}

"""The result of performing a subgraph check, including all steps."""
type CheckPartialSchemaResult {
  """Result of compostion run as part of the overall subgraph check."""
  compositionValidationResult: CompositionCheckResult!
  """Overall result of the check. This will be null if composition validation was unsuccessful."""
  checkSchemaResult: CheckSchemaResult
  """Whether any modifications were detected in the composed core schema."""
  coreSchemaModified: Boolean!
}

"""The possible results of a request to initiate schema checks (either a success object or one of multiple `Error` objects)."""
union CheckRequestResult = CheckRequestSuccess | InvalidInputError | PermissionError | PlanError

"""Represents a successfully initiated execution of schema checks. This does not indicate the _result_ of the checks, only that they were initiated."""
type CheckRequestSuccess {
  """The URL of the Apollo Studio page for this check."""
  targetURL: String!
  """The unique ID for this execution of schema checks."""
  workflowID: ID!
}

"""Input type to provide when running schema checks asynchronously for a non-federated graph."""
input CheckSchemaAsyncInput {
  """Configuration options for the check execution."""
  config: HistoricQueryParametersInput!
  """The GitHub context to associate with the check."""
  gitContext: GitContextInput!
  graphRef: ID @deprecated(reason: "This field is not required to be sent anymore")
  """The URL of the GraphQL endpoint that Apollo Sandbox introspected to obtain the proposed schema. Required if `isSandbox` is `true`."""
  introspectionEndpoint: String
  """If `true`, the check was initiated by Apollo Sandbox."""
  isSandbox: Boolean!
  proposedSchemaDocument: String
}

"""The result of running schema checks on a graph variant."""
type CheckSchemaResult {
  """The schema diff and affected operations generated by the schema check."""
  diffToPrevious: SchemaDiff!
  """The URL to view the schema diff in Studio."""
  targetUrl: String
}

type CheckWorkflow {
  """
  The variant provided as a base to check against. Only the differences from the
  base schema will be tested in operations checks.
  """
  baseVariant: GraphVariant
  """The timestamp when the check workflow completed."""
  completedAt: Timestamp
  id: ID!
  """The name of the implementing service that was responsible for triggering the validation."""
  implementingServiceName: String
  """The timestamp when the check workflow started."""
  startedAt: Timestamp
  """Overall status of the workflow, based on the underlying task statuses."""
  status: CheckWorkflowStatus!
  """The set of check tasks associated with this workflow, e.g. composition, operations, etc."""
  tasks: [CheckWorkflowTask!]!
  """Contextual parameters supplied by the runtime environment where the check was run."""
  gitContext: GitContext
  createdAt: Timestamp!
}

enum CheckWorkflowStatus {
  FAILED
  PASSED
  PENDING
}

interface CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  id: ID!
  """
  The status of this task. All tasks start with the PENDING status while initializing. If any
   prerequisite task fails, then the task status becomes BLOCKED. Otherwise, if all prerequisite
   tasks pass, then this task runs (still having the PENDING status). Once the task completes, the
   task status will become either PASSED or FAILED.
  """
  status: CheckWorkflowTaskStatus!
  """A studio UI url to view the details of this check workflow task"""
  targetURL: String
  """The workflow that this task belongs to."""
  workflow: CheckWorkflow!
}

enum CheckWorkflowTaskStatus {
  BLOCKED
  FAILED
  PASSED
  PENDING
}

"""Filter options to exclude by client reference ID, client name, and client version."""
input ClientInfoFilter {
  name: String!
  """Ignored"""
  referenceID: ID
  version: String
}

"""The result of supergraph composition that Studio performed in response to an attempted deletion of a subgraph."""
type SubgraphRemovalResult {
  """A list of errors that occurred during composition. Errors mean that Apollo was unable to compose the graph variant's subgraphs into a supergraph schema. If any errors are present, gateways / routers are not updated."""
  errors: [SchemaCompositionError]!
  """Whether this composition result resulted in a new supergraph schema passed to Uplink (`true`), or the build failed for any reason (`false`). For dry runs, this value is `true` if Uplink _would have_ been updated with the result."""
  updatedGateway: Boolean!
}

"""The result of supergraph composition that Studio performed in response to an attempted publish of a subgraph."""
type SubgraphPublicationResult {
  """The generated composition config, or null if any errors occurred."""
  compositionConfig: CompositionConfig
  """A list of errors that occurred during composition. Errors mean that Apollo was unable to compose the graph variant's subgraphs into a supergraph schema. If any errors are present, gateways / routers are not updated."""
  errors: [SchemaCompositionError]!
  """Whether this composition result resulted in a new supergraph schema passed to Uplink (`true`), or the build failed for any reason (`false`). For dry runs, this value is `true` if Uplink _would have_ been updated with the result."""
  updatedGateway: Boolean!
  """Whether a new subgraph was created as part of this publish."""
  wasCreated: Boolean!
  """The URL of the Studio page for this update's associated launch, if available."""
  launchUrl: String
  """Human-readable text describing the launch result of the subgraph publish."""
  launchCliCopy: String
}

type CompositionBuildInput {
  subgraphs: [Subgraph!]!
  version: String
}

type CompositionCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  """
  Whether the build's output supergraph core schema differs from that of the active publish for
  the workflow's variant at the time this field executed (NOT at the time the check workflow
  started).
  """
  coreSchemaModified: Boolean!
  createdAt: Timestamp!
  id: ID!
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
  """
  An old version of buildResult that returns a very old GraphQL type that generally should be
  avoided. This field will soon be deprecated.
  """
  result: CompositionResult
}

"""Composition configuration exposed to the gateway."""
type CompositionConfig {
  """The resulting API schema's SHA256 hash, represented as a hexadecimal string."""
  schemaHash: String!
}

"""The result of supergraph composition that Studio performed."""
type CompositionPublishResult implements CompositionResult {
  """The unique ID for this instance of composition."""
  graphCompositionID: ID!
  """A list of errors that occurred during composition. Errors mean that Apollo was unable to compose the graph variant's subgraphs into a supergraph schema. If any errors are present, gateways / routers are not updated."""
  errors: [SchemaCompositionError!]!
  """The supergraph SDL generated by composition."""
  supergraphSdl: GraphQLDocument
}

"""The result of supergraph composition performed by Apollo Studio, often as the result of a subgraph check or subgraph publish. See individual implementations for more details."""
interface CompositionResult {
  """The unique ID for this instance of composition."""
  graphCompositionID: ID!
  """A list of errors that occurred during composition. Errors mean that Apollo was unable to compose the graph variant's subgraphs into a supergraph schema. If any errors are present, gateways / routers are not updated."""
  errors: [SchemaCompositionError!]!
  """Supergraph SDL generated by composition."""
  supergraphSdl: GraphQLDocument
}

"""The result of composition validation run by Apollo Studio during a subgraph check."""
type CompositionCheckResult implements CompositionResult {
  """The unique ID for this instance of composition."""
  graphCompositionID: ID!
  """A list of errors that occurred during composition. Errors mean that Apollo was unable to compose the graph variant's subgraphs into a supergraph schema. If any errors are present, gateways / routers are not updated."""
  errors: [SchemaCompositionError!]!
  """The supergraph schema document generated by composition."""
  supergraphSdl: GraphQLDocument
}

type ContractVariantUpsertErrors {
  """A list of all errors that occurred when attempting to create or update a contract variant."""
  errorMessages: [String!]!
}

union ContractVariantUpsertResult = ContractVariantUpsertErrors | ContractVariantUpsertSuccess

type ContractVariantUpsertSuccess {
  """The updated contract variant"""
  contractVariant: GraphVariant!
  """Human-readable text describing the launch result of the contract update."""
  launchCliCopy: String
  """The URL of the Studio page for this update's associated launch, if available."""
  launchUrl: String
}

"""Contains the supergraph and API schemas generated by composition."""
type CoreSchema {
  """The composed API schema document."""
  apiDocument: GraphQLDocument!
  """The composed supergraph schema document."""
  coreDocument: GraphQLDocument!
  """The supergraph schema document's SHA256 hash, represented as a hexadecimal string."""
  coreHash: String!
}

union CreateOperationCollectionResult = OperationCollection | PermissionError | ValidationError

"""
Implement the DateTime<Utc> scalar

The input/output is a string in RFC3339 format.
"""
scalar DateTime @specifiedBy(url: "https://datatracker.ietf.org/doc/html/rfc3339")

union DeleteOperationCollectionResult = PermissionError

"""The result of attempting to delete a graph variant."""
type GraphVariantDeletionResult {
  """Whether the variant was deleted or not."""
  deleted: Boolean!
}

"""The result of a schema checks workflow that was run on a downstream variant as part of checks for the corresponding source variant. Most commonly, these downstream checks are [contract checks](https://www.apollographql.com/docs/studio/contracts#contract-checks)."""
type DownstreamCheckResult {
  """Whether the downstream check workflow blocks the upstream check workflow from completing."""
  blocking: Boolean!
  """The ID of the graph that the downstream variant belongs to."""
  downstreamGraphID: String!
  """The name of the downstream variant."""
  downstreamVariantName: String!
  """
  The downstream checks workflow that this result corresponds to. This value is null
  if the workflow hasn't been initialized yet, or if the downstream variant was deleted.
  """
  downstreamWorkflow: CheckWorkflow
  """
  Whether the downstream check workflow is causing the upstream check workflow to fail. This occurs
  when the downstream check workflow is both blocking and failing. This may be null while the
  downstream check workflow is pending.
  """
  failsUpstreamWorkflow: Boolean
  """The downstream checks task that this result corresponds to."""
  workflowTask: DownstreamCheckTask!
}

type DownstreamCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  id: ID!
  """
  A list of results for all downstream checks triggered as part of the source variant's checks workflow.
  This value is null if the task hasn't been initialized yet, or if the build task fails (the build task is a
  prerequisite to this task). This value is _not_ null _while_ the task is running. The returned list is empty
  if the source variant has no downstream variants.
  """
  results: [DownstreamCheckResult!]
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
}

interface Error {
  message: String!
}

"""A single subgraph in a supergraph. Every supergraph managed by Apollo Studio includes at least one subgraph. See https://www.apollographql.com/docs/federation/managed-federation/overview/ for more information."""
type GraphVariantSubgraph {
  """The subgraph's name."""
  name: String!
  """The URL of the subgraph's GraphQL endpoint."""
  url: String
  """The current user-provided version/edition of the subgraph. Typically a Git SHA or docker image ID."""
  revision: String!
  """The ID of the graph this subgraph belongs to."""
  graphID: String!
  """The name of the graph variant this subgraph belongs to."""
  graphVariant: String!
  """The subgraph's current active schema, used in supergraph composition for the the associated variant."""
  activePartialSchema: SubgraphSchema!
  """The timestamp when the subgraph was created."""
  createdAt: Timestamp!
  """The timestamp when the subgraph was most recently updated."""
  updatedAt: Timestamp!
}

"""Container for a list of subgraphs composing a supergraph."""
type GraphVariantSubgraphs {
  """The list of underlying subgraphs."""
  services: [GraphVariantSubgraph!]!
}

"""Counts of changes at the field level, including objects, interfaces, and input fields."""
type FieldChangeSummaryCounts {
  """Number of changes that are additions of fields to object, interface, and input types."""
  additions: Int!
  """Number of changes that are removals of fields from object, interface, and input types."""
  removals: Int!
  """
  Number of changes that are field edits. This includes fields changing type and any field
  deprecation and description changes, but also includes any argument changes and any input object
  field changes.
  """
  edits: Int!
}

"""Inputs provided to the build for a contract variant, which filters types and fields from a source variant's schema."""
type FilterBuildInput {
  """Schema filtering rules for the build, such as tags to include or exclude from the source variant schema."""
  filterConfig: FilterConfig!
  """The source variant schema document's SHA256 hash, represented as a hexadecimal string."""
  schemaHash: String!
}

type FilterCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  id: ID!
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
}

"""The filter configuration used to build a contract schema. The configuration consists of lists of tags for schema elements to include or exclude in the resulting schema."""
type FilterConfig {
  """Tags of schema elements to exclude from the contract schema."""
  exclude: [String!]!
  """Tags of schema elements to include in the contract schema."""
  include: [String!]!
}

input FilterConfigInput {
  """A list of tags for schema elements to exclude from the resulting contract schema."""
  exclude: [String!]!
  """
  Whether to hide unreachable objects, interfaces, unions, inputs, enums and scalars from
  the resulting contract schema. Defaults to `false`.
  """
  hideUnreachableTypes: Boolean! = false
  """A list of tags for schema elements to include in the resulting contract schema."""
  include: [String!]!
}

type GitContext {
  commit: ID
}

"""Input type to provide when specifying the Git context for a run of schema checks."""
input GitContextInput {
  """The Git repository branch used in the check."""
  branch: String
  """The ID of the Git commit used in the check."""
  commit: ID
  """The username of the user who created the Git commit used in the check."""
  committer: String
  """The commit message of the Git commit used in the check."""
  message: String
  """The Git repository's remote URL."""
  remoteUrl: String
}

"""
Represents a graph API key, which has permissions scoped to a
user role for a single Apollo graph.
"""
type GraphApiKey implements ApiKey {
  """The timestamp when the API key was created."""
  createdAt: Timestamp!
  """Details of the user or graph that created the API key."""
  createdBy: Identity
  """The API key's ID."""
  id: ID!
  """The API key's name, for distinguishing it from other keys."""
  keyName: String
  """The permission level assigned to the API key upon creation."""
  role: UserPermission!
  """The value of the API key. **This is a secret credential!**"""
  token: String!
}

"""A union of all containers that can comprise the components of a Studio graph"""
union GraphImplementors = GraphVariantSubgraphs

"""A GraphQL document, such as the definition of an operation or schema."""
scalar GraphQLDocument

"""A graph variant"""
type GraphVariant {
  """The variant's global identifier in the form `graphID@variant`."""
  id: ID!
  router: Router
  """The filter configuration used to build a contract schema. The configuration consists of lists of tags for schema elements to include or exclude in the resulting schema."""
  contractFilterConfig: FilterConfig
  """
  A human-readable description of the filter configuration of this contract variant, or null if this isn't a contract
  variant.
  """
  contractFilterConfigDescription: String
  """The graph that this variant belongs to."""
  graph: Graph!
  """Latest approved launch for the variant, and what is served through Uplink."""
  latestApprovedLaunch: Launch
  """Latest launch for the variant, whether successful or not."""
  latestLaunch: Launch
  """The variant's name (e.g., `staging`)."""
  name: String!
  """Which permissions the current user has for interacting with this variant"""
  permissions: GraphVariantPermissions!
  readme: Readme!
  """The variant this variant is derived from. This property currently only exists on contract variants."""
  sourceVariant: GraphVariant
  """A list of the saved [operation collections](https://www.apollographql.com/docs/studio/explorer/operation-collections/) associated with this variant."""
  operationCollections: [OperationCollection!]!
  """The URL of the variant's GraphQL endpoint for query and mutation operations. For subscription operations, use `subscriptionUrl`."""
  url: String
  """The URL of the variant's GraphQL endpoint for subscription operations."""
  subscriptionUrl: String
  """The details of the variant's most recent publication."""
  latestPublication: SchemaPublication
  """A list of the subgraphs included in this variant. This value is null for non-federated variants. Set `includeDeleted` to `true` to include deleted subgraphs."""
  subgraphs(includeDeleted: Boolean! = false): [GraphVariantSubgraph!]
  """Returns the details of the subgraph with the provided `name`, or null if this variant doesn't include a subgraph with that name."""
  subgraph(name: ID!): GraphVariantSubgraph
}

"""Result of looking up a variant by ref"""
union GraphVariantLookup = GraphVariant | InvalidRefFormat

"""Modifies a variant of a graph, also called a schema tag in parts of our product."""
type GraphVariantMutation {
  """
  _Asynchronously_ kicks off operation checks for a proposed non-federated
  schema change against its associated graph.

  Returns a `CheckRequestSuccess` object with a workflow ID that you can use
  to check status, or an error object if the checks workflow failed to start.
  """
  submitCheckSchemaAsync(input: CheckSchemaAsyncInput!): CheckRequestResult!
  """
  _Asynchronously_ kicks off composition and operation checks for a proposed subgraph schema change against its associated supergraph.

  Returns a `CheckRequestSuccess` object with a workflow ID that you can use
  to check status, or an error object if the checks workflow failed to start.
  """
  submitSubgraphCheckAsync(input: SubgraphCheckAsyncInput!): CheckRequestResult!
  """Updates the [README](https://www.apollographql.com/docs/studio/org/graphs/#the-readme-page) of this variant."""
  updateVariantReadme(
    """The full new text of the README, as a Markdown-formatted string."""
    readme: String!
  ): GraphVariant
  """Delete the variant."""
  delete: GraphVariantDeletionResult!
}

"""Individual permissions for the current user when interacting with a particular Studio graph variant."""
type GraphVariantPermissions {
  """Whether the currently authenticated user is permitted to manage/update this variant's build configuration (e.g., build pipeline version)."""
  canManageBuildConfig: Boolean!
  """Whether the currently authenticated user is permitted to manage/update cloud routers"""
  canManageCloudRouter: Boolean!
  """Whether the currently authenticated user is permitted to update variant-level settings for the Apollo Studio Explorer."""
  canManageExplorerSettings: Boolean!
  """Whether the currently authenticated user is permitted to publish schemas to this variant."""
  canPushSchemas: Boolean!
  """Whether the currently authenticated user is permitted to view this variant's build configuration details (e.g., build pipeline version)."""
  canQueryBuildConfig: Boolean!
  """Whether the currently authenticated user is permitted to view details regarding cloud routers"""
  canQueryCloudRouter: Boolean!
  """Whether the currently authenticated user is permitted to view cloud router logs"""
  canQueryCloudRouterLogs: Boolean!
  """Whether the currently authenticated user is permitted to download schemas associated to this variant."""
  canQuerySchemas: Boolean!
  """Whether the currently authenticated user is permitted to update the README for this variant."""
  canUpdateVariantReadme: Boolean!
  canCreateCollectionInVariant: Boolean!
  canShareCollectionInVariant: Boolean!
}

input HistoricQueryParameters {
  from: String = "-86400"
  to: String = "0"
  """Minimum number of requests within the window for a query to be considered."""
  queryCountThreshold: Int = 1
  """
  Number of requests within the window for a query to be considered, relative to
  total request count. Expected values are between 0 and 0.05 (minimum 5% of total
  request volume)
  """
  queryCountThresholdPercentage: Float = 0
  """A list of operation IDs to filter out during validation."""
  ignoredOperations: [ID!] = null
  """A list of clients to filter out during validation."""
  excludedClients: [ClientInfoFilter!] = null
  """A list of operation names to filter out during validation."""
  excludedOperationNames: [OperationNameFilterInput!] = null
  """
  A list of variants to include in the validation. If no variants are provided
  then this defaults to the "current" variant along with the base variant. The
  base variant indicates the schema that generates diff and marks the metrics that
  are checked for broken queries. We union this base variant with the untagged values('',
  same as null inside of `in`, and 'current') in this metrics fetch. This strategy
  supports users who have not tagged their metrics or schema.
  """
  includedVariants: [String!] = null
}

"""Input type to provide when specifying configuration details for schema checks."""
input HistoricQueryParametersInput {
  """Clients to be excluded from check."""
  excludedClients: [ClientInfoFilter!]
  """Operations to be ignored in this schema check, specified by operation name."""
  excludedOperationNames: [OperationNameFilterInput!]
  """Start time for operations to be checked against. Specified as either a) an ISO formatted date/time string or b) a negative number of seconds relative to the time the check request was submitted."""
  from: String
  """Operations to be ignored in this schema check, specified by ID."""
  ignoredOperations: [ID!]
  """Graph variants to be included in check."""
  includedVariants: [String!]
  """Maximum number of queries to be checked against the change."""
  queryCountThreshold: Int
  """Only fail check if this percentage of operations would be negatively impacted."""
  queryCountThresholdPercentage: Float
  """End time for operations to be checked against. Specified as either a) an ISO formatted date/time string or b) a negative number of seconds relative to the time the check request was submitted."""
  to: String
}

"""An identity (such as a `User` or `Graph`) in Apollo Studio. See implementing types for details."""
interface Identity {
  """Returns a representation of the identity as an `Actor` type."""
  asActor: Actor!
  """The identity's identifier, which is unique among objects of its type."""
  id: ID!
  """The identity's human-readable name."""
  name: String!
}

type InternalIdentity implements Identity {
  accounts: [Organization!]!
  asActor: Actor!
  email: String
  id: ID!
  name: String!
}

input IntrospectionDirectiveInput {
  name: String!
  description: String
  locations: [IntrospectionDirectiveLocation!]!
  args: [IntrospectionInputValueInput!]!
  isRepeatable: Boolean
}

"""__DirectiveLocation introspection type"""
enum IntrospectionDirectiveLocation {
  """Location adjacent to a query operation."""
  QUERY
  """Location adjacent to a mutation operation."""
  MUTATION
  """Location adjacent to a subscription operation."""
  SUBSCRIPTION
  """Location adjacent to a field."""
  FIELD
  """Location adjacent to a fragment definition."""
  FRAGMENT_DEFINITION
  """Location adjacent to a fragment spread."""
  FRAGMENT_SPREAD
  """Location adjacent to an inline fragment."""
  INLINE_FRAGMENT
  """Location adjacent to a variable definition."""
  VARIABLE_DEFINITION
  """Location adjacent to a schema definition."""
  SCHEMA
  """Location adjacent to a scalar definition."""
  SCALAR
  """Location adjacent to an object type definition."""
  OBJECT
  """Location adjacent to a field definition."""
  FIELD_DEFINITION
  """Location adjacent to an argument definition."""
  ARGUMENT_DEFINITION
  """Location adjacent to an interface definition."""
  INTERFACE
  """Location adjacent to a union definition."""
  UNION
  """Location adjacent to an enum definition."""
  ENUM
  """Location adjacent to an enum value definition."""
  ENUM_VALUE
  """Location adjacent to an input object type definition."""
  INPUT_OBJECT
  """Location adjacent to an input object field definition."""
  INPUT_FIELD_DEFINITION
}

"""__EnumValue introspection type"""
input IntrospectionEnumValueInput {
  name: String!
  description: String
  isDeprecated: Boolean!
  deprecationReason: String
}

"""__Field introspection type"""
input IntrospectionFieldInput {
  name: String!
  description: String
  args: [IntrospectionInputValueInput!]!
  type: IntrospectionTypeInput!
  isDeprecated: Boolean!
  deprecationReason: String
}

"""__Value introspection type"""
input IntrospectionInputValueInput {
  name: String!
  description: String
  type: IntrospectionTypeInput!
  defaultValue: String
  isDeprecated: Boolean
  deprecationReason: String
}

"""__Schema introspection type"""
input IntrospectionSchemaInput {
  types: [IntrospectionTypeInput!]
  queryType: IntrospectionTypeRefInput!
  mutationType: IntrospectionTypeRefInput
  subscriptionType: IntrospectionTypeRefInput
  directives: [IntrospectionDirectiveInput!]!
  description: String
}

"""__Type introspection type"""
input IntrospectionTypeInput {
  kind: IntrospectionTypeKind!
  name: String
  description: String
  specifiedByUrl: String
  fields: [IntrospectionFieldInput!]
  interfaces: [IntrospectionTypeInput!]
  possibleTypes: [IntrospectionTypeInput!]
  enumValues: [IntrospectionEnumValueInput!]
  inputFields: [IntrospectionInputValueInput!]
  ofType: IntrospectionTypeInput
}

enum IntrospectionTypeKind {
  """Indicates this type is a scalar."""
  SCALAR
  """Indicates this type is an object. 'fields' and 'interfaces' are valid fields."""
  OBJECT
  """
  Indicates this type is an interface. 'fields' and 'possibleTypes' are valid
  fields
  """
  INTERFACE
  """Indicates this type is a union. 'possibleTypes' is a valid field."""
  UNION
  """Indicates this type is an enum. 'enumValues' is a valid field."""
  ENUM
  """Indicates this type is an input object. 'inputFields' is a valid field."""
  INPUT_OBJECT
  """Indicates this type is a list. 'ofType' is a valid field."""
  LIST
  """Indicates this type is a non-null. 'ofType' is a valid field."""
  NON_NULL
}

"""Shallow __Type introspection type"""
input IntrospectionTypeRefInput {
  name: String!
  kind: String
}

"""An error caused by providing invalid input for a task, such as schema checks."""
type InvalidInputError {
  """The error message."""
  message: String!
}

"""This object is returned when a request to fetch a Studio graph variant provides an invalid graph ref."""
type InvalidRefFormat implements Error {
  message: String!
}

"""Represents the complete process of making a set of updates to a deployed graph variant."""
type Launch {
  """The unique identifier for this launch."""
  id: ID!
  """The ID of the launch's associated graph."""
  graphId: String!
  """The name of the launch's associated variant."""
  graphVariant: String!
  order: OrderOrError!
  """The timestamp when the launch was approved."""
  approvedAt: Timestamp
  """The associated build for this launch (a build includes schema composition and contract filtering). This value is null until the build is initiated."""
  build: Build
  """The inputs provided to this launch's associated build, including subgraph schemas and contract filters."""
  buildInput: BuildInput!
  """The timestamp when the launch completed. This value is null until the launch completes."""
  completedAt: Timestamp
  """The timestamp when the launch was initiated."""
  createdAt: Timestamp!
  """Contract launches that were triggered by this launch."""
  downstreamLaunches: [Launch!]!
  """Whether the launch completed."""
  isCompleted: Boolean
  """Whether the result of the launch has been published to the associated graph and variant. This is always false for a failed launch."""
  isPublished: Boolean
  """The most recent launch sequence step that has started but not necessarily completed."""
  latestSequenceStep: LaunchSequenceStep
  """A specific publication of a graph variant pertaining to this launch."""
  publication: SchemaPublication
  """A list of results from the completed launch. The items included in this list vary depending on whether the launch succeeded, failed, or was superseded."""
  results: [LaunchResult!]!
  """Cloud router configuration associated with this build event. It will be non-null for any cloud-router variant, and null for any not cloudy variant/graph."""
  routerConfig: String
  """A list of all serial steps in the launch sequence. This list can change as the launch progresses. For example, a `LaunchCompletedStep` is appended after a launch completes."""
  sequence: [LaunchSequenceStep!]!
  """A shortened version of `Launch.id` that includes only the first 8 characters."""
  shortenedID: String!
  """The launch's status. If a launch is superseded, its status remains `LAUNCH_INITIATED`. To check for a superseded launch, use `supersededAt`."""
  status: LaunchStatus!
  """A list of subgraph changes that are included in this launch."""
  subgraphChanges: [SubgraphChange!]
  """The timestamp when this launch was superseded by another launch. If an active launch is superseded, it terminates."""
  supersededAt: Timestamp
  """The launch that superseded this launch, if any. If an active launch is superseded, it terminates."""
  supersededBy: Launch
  """The source variant launch that caused this launch to be initiated. This value is present only for contract variant launches. Otherwise, it's null."""
  upstreamLaunch: Launch
}

"""Types of results that can be associated with a `Launch`"""
union LaunchResult = ChangelogLaunchResult

"""The timing details for the build step of a launch."""
type LaunchSequenceBuildStep {
  """The timestamp when the step completed."""
  completedAt: Timestamp
  """The timestamp when the step started."""
  startedAt: Timestamp
}

"""The timing details for the checks step of a launch."""
type LaunchSequenceCheckStep {
  """The timestamp when the step completed."""
  completedAt: Timestamp
  """The timestamp when the step started."""
  startedAt: Timestamp
}

"""The timing details for the completion step of a launch."""
type LaunchSequenceCompletedStep {
  """The timestamp when the step (and therefore the launch) completed."""
  completedAt: Timestamp
}

"""The timing details for the initiation step of a launch."""
type LaunchSequenceInitiatedStep {
  """The timestamp when the step (and therefore the launch) started."""
  startedAt: Timestamp
}

"""The timing details for the publish step of a launch."""
type LaunchSequencePublishStep {
  """The timestamp when the step completed."""
  completedAt: Timestamp
  """The timestamp when the step started."""
  startedAt: Timestamp
}

"""Represents the various steps that occur in sequence during a single launch."""
union LaunchSequenceStep = LaunchSequenceBuildStep | LaunchSequenceCheckStep | LaunchSequenceCompletedStep | LaunchSequenceInitiatedStep | LaunchSequencePublishStep | LaunchSequenceSupersededStep

"""The timing details for the superseded step of a launch. This step occurs only if the launch is superseded by another launch."""
type LaunchSequenceSupersededStep {
  """The timestamp when the step completed, thereby ending the execution of this launch in favor of the superseding launch."""
  completedAt: Timestamp
}

enum LaunchStatus {
  LAUNCH_COMPLETED
  LAUNCH_FAILED
  LAUNCH_INITIATED
}

enum LogLevel {
  WARN
  INFO
  ERROR
  DEBUG
}

type LogMessage {
  """Timestamp in UTC"""
  timestamp: DateTime!
  """Log message contents"""
  message: String!
  """Log level"""
  level: LogLevel!
}

type Mutation {
  """Provides access to mutation fields for modifying a Studio graph with the provided ID."""
  graph(id: ID!): GraphMutation
  """
  Provides access to mutation fields for modifying an Apollo user with the
  provided ID.
  """
  user(id: ID!): UserMutation
  """Creates an [operation collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/) for a given variant, or creates a [sandbox collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/#sandbox-collections) without an associated variant."""
  createOperationCollection(
    """The collection's description."""
    description: String
    """Whether the collection is a [sandbox collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/#sandbox-collections)."""
    isSandbox: Boolean!
    """Whether the collection is shared across its associated organization."""
    isShared: Boolean!
    """The minimum role a user needs to edit this collection. Valid values: null, CONSUMER, OBSERVER, DOCUMENTER, CONTRIBUTOR, GRAPH_ADMIN. This value is ignored if `isShared` is `false`. The default value is  `GRAPH_ADMIN`."""
    minEditRole: UserPermission
    """The collection's name."""
    name: String!
    """The [graph ref](https://www.apollographql.com/docs/rover/conventions/#graph-refs) of the graph variants to associate the collection with."""
    variantRefs: [ID!]
  ): CreateOperationCollectionResult!
  operationCollection(id: ID!): OperationCollectionMutation
}

"""
ISO 8601 combined date and time without timezone.

# Examples

* `2015-07-01T08:59:60.123`,
"""
scalar NaiveDateTime

type NamedIntrospectionArg {
  name: String
  description: String
}

"""
The shared fields for a named introspection type. Currently this is returned for the
top level value affected by a change. In the future, we may update this
type to be an interface, which is extended by the more specific types:
scalar, object, input object, union, interface, and enum

For an in-depth look at where these types come from, see:
https://github.com/DefinitelyTyped/DefinitelyTyped/blob/659eb50d3/types/graphql/utilities/introspectionQuery.d.ts#L31-L37
"""
type NamedIntrospectionType {
  kind: IntrospectionTypeKind
  name: String
  description: String
}

"""
Introspection values that can be children of other types for changes, such
as input fields, objects in interfaces, enum values. In the future, this
value could become an interface to allow fields specific to the types
returned.
"""
type NamedIntrospectionValue {
  name: String
  description: String
  printedType: String
}

"""An error that occurs when a requested object is not found."""
type NotFoundError implements Error {
  """The error message."""
  message: String!
}

"""A list of saved GraphQL operations."""
type OperationCollection {
  """The timestamp when the collection was created."""
  createdAt: Timestamp!
  """The user or other entity that created the collection."""
  createdBy: Identity
  """The collection's description. A `null` description was never set, and empty string description was set to be empty string by a user, or other entity."""
  description: String
  id: ID!
  """Whether the current user has marked the collection as a favorite."""
  isFavorite: Boolean!
  """Whether the collection is a [sandbox collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/#sandbox-collections)."""
  isSandbox: Boolean!
  """Whether the collection is shared across its associated organization."""
  isShared: Boolean!
  """The timestamp when the collection was most recently updated."""
  lastUpdatedAt: Timestamp!
  """The user or other entity that most recently updated the collection."""
  lastUpdatedBy: Identity
  """The minimum role a user needs to edit this collection. Valid values: null, CONSUMER, OBSERVER, DOCUMENTER, CONTRIBUTOR, GRAPH_ADMIN. This value is always `null` if `isShared` is `false`. If `null` when `isShared` is `true`, the minimum role is `GRAPH_ADMIN`."""
  minEditRole: UserPermission
  """The collection's name."""
  name: String!
  """Returns the operation in the collection with the specified ID, if any."""
  operation(id: ID!): OperationCollectionEntryResult
  """A list of the GraphQL operations that belong to the collection."""
  operations: [OperationCollectionEntry!]!
  """The permissions that the current user has for the collection."""
  permissions: OperationCollectionPermissions!
}

"""A saved operation entry within an Operation Collection."""
type OperationCollectionEntry {
  """The timestamp when the entry was created."""
  createdAt: Timestamp!
  """The user or other entity that created the entry."""
  createdBy: Identity
  """Details of the entry's associated operation, such as its `body` and `variables`."""
  currentOperationRevision: OperationCollectionEntryState!
  id: ID!
  """The timestamp when the entry was most recently updated."""
  lastUpdatedAt: Timestamp!
  """The user or other entity that most recently updated the entry."""
  lastUpdatedBy: Identity
  """The entry's name."""
  name: String!
  """The entry's lexicographical ordering index within its containing collection."""
  orderingIndex: String!
}

"""Provides fields for modifying an operation in a collection."""
type OperationCollectionEntryMutation {
  """Updates the name of an operation."""
  updateName(name: String!): UpdateOperationCollectionEntryResult
  """Updates the body, headers, and/or variables of an operation."""
  updateValues(operationInput: OperationCollectionEntryStateInput!): UpdateOperationCollectionEntryResult
}

union OperationCollectionEntryMutationResult = NotFoundError | OperationCollectionEntryMutation | PermissionError

"""Possible return values when querying for an entry in an operation collection (either the entry object or an `Error` object)."""
union OperationCollectionEntryResult = NotFoundError | OperationCollectionEntry

"""The most recent body, variable and header values of a saved operation entry."""
type OperationCollectionEntryState {
  """The raw body of the entry's GraphQL operation."""
  body: String!
  """Headers for the entry's GraphQL operation."""
  headers: [OperationHeader!]
  """Variables for the entry's GraphQL operation, as a JSON string."""
  variables: String
}

"""Fields for creating or modifying an operation collection entry."""
input OperationCollectionEntryStateInput {
  """The operation's query body."""
  body: String!
  """The operation's headers."""
  headers: [OperationHeaderInput!]
  """The operation's variables."""
  variables: String
}

"""Provides fields for modifying an [operation collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/)."""
type OperationCollectionMutation {
  """Adds an operation to this collection."""
  addOperation(name: String!, operationInput: OperationCollectionEntryStateInput!): AddOperationCollectionEntryResult
  """Adds operations to this collection."""
  addOperations(operations: [AddOperationInput!]!): AddOperationCollectionEntriesResult
  """Deletes this operation collection. This also deletes all of the collection's associated operations."""
  delete: DeleteOperationCollectionResult
  """Deletes an operation from this collection."""
  deleteOperation(id: ID!): RemoveOperationCollectionEntryResult
  operation(id: ID!): OperationCollectionEntryMutationResult
  """Updates the minimum role a user needs to be able to modify this collection."""
  setMinEditRole(editRole: UserPermission): UpdateOperationCollectionResult
  """Updates this collection's description."""
  updateDescription(description: String): UpdateOperationCollectionResult
  """Updates whether the current user has marked this collection as a favorite."""
  updateIsFavorite(isFavorite: Boolean!): UpdateOperationCollectionResult
  """Updates whether this collection is shared across its associated organization."""
  updateIsShared(isShared: Boolean!): UpdateOperationCollectionResult
  """Updates this operation collection's name."""
  updateName(name: String!): UpdateOperationCollectionResult
}

"""Whether the current user can perform various actions on the associated collection."""
type OperationCollectionPermissions {
  """Whether the current user can edit operations in the associated collection."""
  canEditOperations: Boolean!
  """Whether the current user can delete or update the associated collection's metadata, such as its name and description."""
  canManage: Boolean!
  """Whether the current user can read operations in the associated collection."""
  canReadOperations: Boolean!
}

union OperationCollectionResult = NotFoundError | OperationCollection | PermissionError | ValidationError

"""Saved headers on a saved operation."""
type OperationHeader {
  """The header's name."""
  name: String!
  """The header's value."""
  value: String!
}

input OperationHeaderInput {
  """The header's name."""
  name: String!
  """The header's value."""
  value: String!
}

"""Options to filter by operation name."""
input OperationNameFilterInput {
  """name of the operation set by the user and reported alongside metrics"""
  name: String!
  version: String
}

type OperationsCheckResult {
  id: ID!
  """Indication of the success of the change, either failure, warning, or notice."""
  checkSeverity: ChangeSeverity!
  """Number of operations that were validated during schema diff"""
  numberOfCheckedOperations: Int!
  """List of schema changes with associated affected clients and operations"""
  changes: [Change!]!
  """Summary/counts for all changes in diff"""
  changeSummary: ChangeSummary!
  """Operations affected by all changes in diff"""
  affectedQueries: [AffectedQuery!]
  """Number of affected query operations that are neither marked as SAFE or IGNORED"""
  numberOfAffectedOperations: Int!
  createdAt: Timestamp!
}

type OperationsCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  id: ID!
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
  """
  The result of the operations check. This will be null when the task is initializing or running,
  or when the build task fails (which is a prerequisite task to this one).
  """
  result: OperationsCheckResult
}

type Order {
  id: ID!
  orderType: OrderType!
  status: OrderStatus!
  reason: String
  logs(first: Int, offset: Int): [LogMessage!]!
  router: Router!
}

union OrderOrError = Order

enum OrderStatus {
  PENDING
  COMPLETED
  ROLLING_BACK
  ERRORED
  SUPERSEDED
}

enum OrderType {
  CREATE_ROUTER
  DESTROY_ROUTER
  UPDATE_ROUTER
}

"""The schema for a single published subgraph in Studio."""
type SubgraphSchema {
  """The subgraph schema document as SDL."""
  sdl: String!
}

"""
Input for registering a partial schema to an implementing service.
One of the fields must be specified (validated server-side).

If a new partialSchemaSDL is passed in, this operation will store it before
creating the association.

If both the sdl and hash are specified, an error will be thrown if the provided
hash doesn't match our hash of the sdl contents. If the sdl field is specified,
the hash does not need to be and will be computed server-side.
"""
input PartialSchemaInput {
  """
  Contents of the partial schema in SDL syntax, but may reference types
  that aren't defined in this document
  """
  sdl: String
  """
  Hash of the partial schema to associate; error is thrown if only the hash is
  specified and the hash has not been seen before
  """
  hash: String
}

"""An error that occurs when the current user doesn't have sufficient permissions to perform an action."""
type PermissionError implements Error {
  """The error message."""
  message: String!
}

"""An error related to an organization's Apollo Studio plan."""
type PlanError {
  """The error message."""
  message: String!
}

type Query {
  """Returns the root URL of the Apollo Studio frontend."""
  frontendUrlRoot: String!
  """Returns details of the graph with the provided ID."""
  graph(id: ID!): Graph
  """Returns details of the authenticated `User` or `Graph` executing this query. If this is an unauthenticated query (i.e., no API key is provided), this field returns null."""
  me: Identity
  """Returns details of the Studio organization with the provided ID."""
  organization(id: ID!): Organization
  """Returns details of the Apollo user with the provided ID."""
  user(id: ID!): User
  """Returns details of a Studio graph variant with the provided graph ref. A graph ref has the format `graphID@variantName` (or just `graphID` for the default variant `current`). Returns null if the graph or variant doesn't exist, or if the graph isn't accessible by the current actor."""
  variant(ref: ID!): GraphVariantLookup
  """Returns the [operation collection](https://www.apollographql.com/docs/studio/explorer/operation-collections/) for the provided ID."""
  operationCollection(id: ID!): OperationCollectionResult!
}

"""The README documentation for a graph variant, which is displayed in Studio."""
type Readme {
  """The contents of the README in plaintext."""
  content: String!
  """The README's unique ID. `a15177c0-b003-4837-952a-dbfe76062eb1` for the default README"""
  id: ID!
  """The actor that most recently updated the README (usually a `User`). `null` for the default README, or if the `User` was deleted."""
  lastUpdatedBy: Identity
  """The timestamp when the README was most recently updated. `null` for the default README"""
  lastUpdatedTime: Timestamp
}

union RemoveOperationCollectionEntryResult = OperationCollection | PermissionError

type Router {
  """
  Last time when the Cloud Router was updated

  If the Cloud Router was never updated, this value will be null
  """
  updatedAt: NaiveDateTime
  """Current status of the Cloud Router"""
  status: RouterStatus!
  """Current version of the Cloud Router"""
  routerVersion: RouterVersion!
  """
  URL where the Cloud Router can be found

  This will be null if the Cloud Router is in a deleted status
  """
  routerUrl: String
  """Retrieves a specific Order related to this Cloud Router"""
  order(orderId: ID!): Order
  """Retrieves all Orders related to this Cloud Router"""
  orders(first: Int, offset: Int): [Order!]!
  """Return the list of secrets for this Cloud Router with their hash values"""
  secrets: [Secret!]!
}

enum RouterStatus {
  CREATING
  UPDATING
  DELETING
  ROLLING_BACK
  RUNNING
  DELETED
}

type RouterVersion {
  version: String!
  core: String!
  build: String!
  status: Status!
  configVersion: String!
  configSchema: String!
}

"""A GraphQL schema document and associated metadata."""
type Schema {
  """The GraphQL schema document's SHA256 hash, represented as a hexadecimal string."""
  hash: ID!
  """The GraphQL schema document."""
  document: GraphQLDocument!
}

"""An error that occurred while running schema composition on a set of subgraph schemas."""
type SchemaCompositionError {
  """A human-readable message describing the error."""
  message: String!
  """Source locations related to the error."""
  locations: [SourceLocation]!
  """A machine-readable error code."""
  code: String
}

"""The result of computing the difference between two schemas, usually as part of schema checks."""
type SchemaDiff {
  """Indicates the overall safety of the changes included in the diff, based on operation history (e.g., `FAILURE` or `NOTICE`)."""
  severity: ChangeSeverity!
  """A list of all schema changes in the diff, including their severity."""
  changes: [Change!]!
  """Numeric summaries for each type of change in the diff."""
  changeSummary: ChangeSummary!
  """Operations affected by all changes in the diff."""
  affectedQueries: [AffectedQuery!]
  """The number of GraphQL operations that were validated during the check."""
  numberOfCheckedOperations: Int
  """The number of GraphQL operations affected by the diff's changes that are neither marked as safe nor ignored."""
  numberOfAffectedOperations: Int!
}

"""Contains details for an individual publication of an individual graph variant."""
type SchemaPublication {
  """
  The variant that was published to."
  """
  variant: GraphVariant!
  """The schema that was published to the variant."""
  schema: Schema!
  """The result of federated composition executed for this publication. This result includes either a supergraph schema or error details, depending on whether composition succeeded. This value is null when the publication is for a non-federated graph."""
  compositionResult: CompositionResult
  """The timestamp when the variant was published to."""
  publishedAt: Timestamp!
  """A schema diff comparing against the schema from the most recent previous successful publication."""
  diffToPrevious: SchemaDiff
}

type Secret {
  createdAt: DateTime!
  name: String!
  hash: String!
}

type SemanticChange {
  """Semantic metadata about the type of change"""
  definition: ChangeDefinition!
  """Top level node affected by the change"""
  parentNode: NamedIntrospectionType
  """
  Node related to the top level node that was changed, such as a field in an object,
  a value in an enum or the object of an interface
  """
  childNode: NamedIntrospectionValue
  """Target arg of change made."""
  argNode: NamedIntrospectionArg
}

"""
A graph in Apollo Studio represents a graph in your organization.
Each graph has one or more variants, which correspond to the different environments where that graph runs (such as staging and production).
Each variant has its own GraphQL schema, which means schemas can differ between environments.
"""
type Graph implements Identity {
  """The organization that this graph belongs to."""
  account: Organization
  """A list of the graph API keys that are active for this graph."""
  apiKeys: [GraphApiKey!]
  """Provides a view of the graph as an `Actor` type."""
  asActor: Actor!
  """Get a check workflow for this graph by its ID"""
  checkWorkflow(id: ID!): CheckWorkflow
  """The graph's globally unique identifier."""
  id: ID!
  """Permissions of the current user in this graph."""
  myRole: UserPermission
  name: String!
  """Describes the permissions that the active user has for this graph."""
  roles: GraphRoles
  """The graph's name."""
  title: String!
  """
  Provides details of the graph variant with the provided `name`, if a variant
  with that name exists for this graph. Otherwise, returns null.

   For a list of _all_ variants associated with a graph, use `Graph.variants` instead.
  """
  variant(name: String!): GraphVariant
  """A list of the variants for this graph."""
  variants: [GraphVariant!]!
  """Get a GraphQL document by hash"""
  document(hash: SHA256): GraphQLDocument
  """Get check workflows for this graph ordered by creation time, most recent first."""
  checkWorkflows(limit: Int! = 100, filter: CheckFilterInput): [CheckWorkflow!]!
}

"""Provides access to mutation fields for managing Studio graphs and subgraphs."""
type GraphMutation {
  """Generates a new graph API key for this graph with the specified permission level."""
  newKey(keyName: String, role: UserPermission! = GRAPH_ADMIN): GraphApiKey!
  """Deletes the existing graph API key with the provided ID, if any."""
  removeKey(
    """API key ID"""
    id: ID!
  ): Void
  """Sets a new name for the graph API key with the provided ID, if any. This does not invalidate the key or change its value."""
  renameKey(id: ID!, newKeyName: String): GraphApiKey
  """Creates a contract schema from a source variant and a set of filter configurations"""
  upsertContractVariant(
    """The name of the contract variant, e.g. `public-api`. Once set, this value cannot be changed."""
    contractVariantName: String!
    """The filter configuration used to build a contract schema. The configuration consists of lists of tags for schema elements to include or exclude in the resulting schema."""
    filterConfig: FilterConfigInput!
    """Whether a launch and schema publish should be initiated after updating configuration. Defaults to `true`."""
    initiateLaunch: Boolean! = true
    """The graphRef of the variant the contract will be derived from, e.g. `my-graph@production`. Once set, this value cannot be changed."""
    sourceVariant: String
  ): ContractVariantUpsertResult!
  """Make changes to a graph variant."""
  variant(name: String!): GraphVariantMutation
  """Publish a schema to this variant, either via a document or an introspection query result."""
  uploadSchema(schema: IntrospectionSchemaInput, schemaDocument: String, tag: String!, historicParameters: HistoricQueryParameters, overrideComposedSchema: Boolean! = false, errorOnBadRequest: Boolean! = true, gitContext: GitContextInput): SchemaPublicationResult
  """
  Checks a proposed schema against the schema that has been published to
  a particular variant, using metrics corresponding to `historicParameters`.
  Callers can set `historicParameters` directly or rely on defaults set in the
  graph's check configuration (7 days by default).
  If they do not set `historicParameters` but set `useMaximumRetention`,
  validation will use the maximum retention the graph has access to.
  """
  checkSchema(
    """
    Only one of proposedSchema, proposedSchemaDocument, and proposedSchemaHash
    may be specified
    """
    proposedSchema: IntrospectionSchemaInput
    proposedSchemaDocument: String
    proposedSchemaHash: String
    baseSchemaTag: String = "current"
    gitContext: GitContextInput
    historicParameters: HistoricQueryParameters
    useMaximumRetention: Boolean
    isSandboxCheck: Boolean! = false
    """If this check is triggered for an sdl fetched using introspection, this is the endpoint where that schema was being served."""
    introspectionEndpoint: String
    """Deprecated and ignored."""
    frontend: String
  ): CheckSchemaResult!
  """Publish to a subgraph. If composition is successful, this will update running routers."""
  publishSubgraph(graphVariant: String!, name: String!, url: String, revision: String!, activePartialSchema: PartialSchemaInput!, gitContext: GitContextInput): SubgraphPublicationResult
  """Removes a subgraph. If composition is successful, this will update running routers."""
  removeImplementingServiceAndTriggerComposition(
    graphVariant: String!
    name: String!
    """Do not remove the service, but recompose without it and report any errors."""
    dryRun: Boolean! = false
  ): SubgraphRemovalResult!
  """
  Checks a proposed subgraph schema change against a published subgraph.
  If the proposal composes successfully, perform a usage check for the resulting supergraph schema.
  """
  checkPartialSchema(
    """The name of the graph variant to run the check against."""
    graphVariant: String!
    """Name of the implementing service to validate the partial schema against"""
    implementingServiceName: String!
    """The partial schema to validate against an implementing service"""
    partialSchema: PartialSchemaInput!
    gitContext: GitContextInput
    historicParameters: HistoricQueryParameters
    """Deprecated and ignored."""
    frontend: String
    """
    Whether to use the maximum retention for historical validation. This only takes
    effect if historicParameters is null.
    """
    useMaximumRetention: Boolean
    isSandboxCheck: Boolean! = false
    """If this check is triggered for an sdl fetched using introspection, this is the endpoint where that schema was being served."""
    introspectionEndpoint: String
  ): CheckPartialSchemaResult!
}

"""Individual permissions for the current user when interacting with a particular Studio graph."""
type GraphRoles {
  """Whether the currently authenticated user is permitted to perform schema checks (i.e., run `rover (sub)graph check`)."""
  canCheckSchemas: Boolean!
  """Whether the currently authenticated user is permitted to create new graph variants."""
  canCreateVariants: Boolean!
  """Whether the currently authenticated user is permitted to delete the graph in question"""
  canDelete: Boolean!
  """Whether the currently authenticated user is permitted to manage user access to the graph in question."""
  canManageAccess: Boolean!
  """Whether the currently authenticated user is permitted to manage the build configuration (e.g., build pipeline version)."""
  canManageBuildConfig: Boolean!
  """Whether the currently authenticated user is permitted to manage third-party integrations (e.g., Datadog forwarding)."""
  canManageIntegrations: Boolean!
  """Whether the currently authenticated user is permitted to manage graph-level API keys."""
  canManageKeys: Boolean!
  """Whether the currently authenticated user is permitted to perform basic administration of variants (e.g., make a variant public)."""
  canManageVariants: Boolean!
  """Whether the currently authenticated user is permitted to view details about the build configuration (e.g. build pipeline version)."""
  canQueryBuildConfig: Boolean!
  """Whether the currently authenticated user is permitted to view details of the check configuration for this graph."""
  canQueryCheckConfiguration: Boolean!
  """Whether the currently authenticated user is permitted to view which subgraphs the graph is composed of."""
  canQueryImplementingServices: Boolean!
  """Whether the currently authenticated user is permitted to download schemas owned by this graph."""
  canQuerySchemas: Boolean!
  """Whether the currently authenticated user is permitted to register operations (i.e. `apollo client:push`) for this graph."""
  canRegisterOperations: Boolean!
  """Whether the currently authenticated user is permitted to make updates to the check configuration for this graph."""
  canWriteCheckConfiguration: Boolean!
}

"""A SHA-256 hash, represented as a lowercase hexadecimal string."""
scalar SHA256

"""A location in a source code file."""
type SourceLocation {
  """Column number."""
  column: Int!
  """Line number."""
  line: Int!
}

enum Status {
  STABLE
  NEXT
  DEPRECATED
}

"""A subgraph in a federated Studio supergraph."""
type Subgraph {
  """The subgraph schema document's SHA256 hash, represented as a hexadecimal string."""
  hash: String!
  """The subgraph's registered name."""
  name: String!
  """The number of fields in this subgraph"""
  numberOfFields: Int
  """The number of types in this subgraph"""
  numberOfTypes: Int
  """The subgraph's routing URL, provided to gateways that use managed federation."""
  routingURL: String!
  """Timestamp of when the subgraph was published."""
  updatedAt: Timestamp
}

"""A change made to a subgraph as part of a launch."""
type SubgraphChange {
  """The subgraph's name."""
  name: ID!
  """The type of change that was made."""
  type: SubgraphChangeType!
}

enum SubgraphChangeType {
  ADDITION
  DELETION
  MODIFICATION
}

"""Input type to provide when running schema checks asynchronously for a federated supergraph."""
input SubgraphCheckAsyncInput {
  """Configuration options for the check execution."""
  config: HistoricQueryParametersInput!
  """The GitHub context to associate with the check."""
  gitContext: GitContextInput!
  """The graph ref of the Studio graph and variant to run checks against (such as `my-graph@current`)."""
  graphRef: ID
  """The URL of the GraphQL endpoint that Apollo Sandbox introspected to obtain the proposed schema. Required if `isSandbox` is `true`."""
  introspectionEndpoint: String
  """If `true`, the check was initiated by Apollo Sandbox."""
  isSandbox: Boolean!
  """The proposed subgraph schema to perform checks with."""
  proposedSchema: GraphQLDocument!
  """The name of the subgraph to check schema changes for."""
  subgraphName: String!
}

"""ISO 8601, extended format with nanoseconds, Zulu (or "[+-]seconds" as a string or number relative to now)"""
scalar Timestamp

"""Counts of changes."""
type TotalChangeSummaryCounts {
  """
  Number of changes that are additions. This includes adding types, adding fields to object, input
  object, and interface types, adding values to enums, adding members to interfaces and unions, and
  adding arguments.
  """
  additions: Int!
  """
  Number of changes that are removals. This includes removing types, removing fields from object,
  input object, and interface types, removing values from enums, removing members from interfaces
  and unions, and removing arguments. This also includes removing @deprecated usages.
  """
  removals: Int!
  """
  Number of changes that are edits. This includes types changing kind, fields and arguments
  changing type, arguments changing default value, and any description changes. This also includes
  edits to @deprecated reason strings.
  """
  edits: Int!
  """Number of changes that are new usages of the @deprecated directive."""
  deprecations: Int!
}

"""Counts of changes at the type level, including interfaces, unions, enums, scalars, input objects, etc."""
type TypeChangeSummaryCounts {
  """Number of changes that are additions of types."""
  additions: Int!
  """Number of changes that are removals of types."""
  removals: Int!
  """
  Number of changes that are edits. This includes types changing kind and any type description
  changes, but also includes adding/removing values from enums, adding/removing members from
  interfaces and unions, and any enum value deprecation and description changes.
  """
  edits: Int!
}

union UpdateOperationCollectionEntryResult = OperationCollectionEntry | PermissionError | ValidationError

union UpdateOperationCollectionResult = OperationCollection | PermissionError | ValidationError

"""Describes the result of publishing a schema to a graph variant."""
type SchemaPublicationResult {
  """A machine-readable response code that indicates the type of result (e.g., `UPLOAD_SUCCESS` or `NO_CHANGES`)"""
  code: String!
  """Whether the schema publish operation succeeded (`true`) or encountered errors (`false`)."""
  success: Boolean!
  """A Human-readable message describing the type of result."""
  message: String!
  """If the publish operation succeeded, this contains its details. Otherwise, this is null."""
  publication: SchemaPublication
}

"""A registered Apollo Studio user."""
type User implements Identity {
  """Returns a list of all active user API keys for the user."""
  apiKeys(includeCookies: Boolean = false): [UserApiKey!]!
  """Returns a representation of this user as an `Actor` type. Useful when determining which actor (usually a `User` or `Graph`) performed a particular action in Studio."""
  asActor: Actor!
  """The user's unique ID."""
  id: ID!
  """A list of the user's memberships in Apollo Studio organizations."""
  memberships: [UserMembership!]!
  """The user's first and last name."""
  name: String!
}

"""
Represents a user API key, which has permissions identical to
its associated Apollo user.
"""
type UserApiKey implements ApiKey {
  """The API key's ID."""
  id: ID!
  """The API key's name, for distinguishing it from other keys."""
  keyName: String
  """The value of the API key. **This is a secret credential!**"""
  token: String!
}

"""A single user's membership in a single Apollo Studio organization."""
type UserMembership {
  """The organization that the user belongs to."""
  account: Organization!
  """The timestamp when the user was added to the organization."""
  createdAt: Timestamp!
  """The user's permission level within the organization."""
  permission: UserPermission!
  """The user that belongs to the organization."""
  user: User!
}

type UserMutation {
  """Creates a new user API key for this user."""
  newKey(keyName: String!): UserApiKey!
  """
  If this user has no active user API keys, this creates one for the user.

  If this user has at least one active user API key, this returns one of those keys at random and does _not_ create a new key.
  """
  provisionKey(keyName: String! = "add-a-name"): ApiKeyProvision
  """Deletes the user API key with the provided ID, if any."""
  removeKey(
    """API key ID"""
    id: ID!
  ): Void
  """Sets a new name for the user API key with the provided ID, if any. This does not invalidate the key or change its value."""
  renameKey(id: ID!, newKeyName: String): UserApiKey
}

enum UserPermission {
  BILLING_MANAGER
  CONSUMER
  CONTRIBUTOR
  DOCUMENTER
  GRAPH_ADMIN
  LEGACY_GRAPH_KEY
  OBSERVER
  ORG_ADMIN
}

"""An error that occurs when an operation contains invalid user input."""
type ValidationError implements Error {
  """The error's details."""
  message: String!
}

"""Always null"""
scalar Void