"""
An organization in Apollo Studio. Can have multiple members and graphs.
"""
type Organization {
  """
  Fetches an offline license for the account.
  (If you need this then please contact your Apollo account manager to discuss your requirements.)
  """
  offlineLicense: RouterLicense

  """
  Globally unique identifier, which isn't guaranteed stable (can be changed by administrators).
  """
  id: ID!

  """The user memberships belonging to an Organization"""
  memberships: [AccountMembership!]

  """Name of the organization, which can change over time and isn't unique."""
  name: String!

  """The session length in seconds for a user in this org"""
  sessionDurationInSeconds: Int
  auditLogExports: [AuditLogExport!]

  """Graphs belonging to this organization."""
  graphs(includeDeleted: Boolean): [Graph!]!

  """Graphs belonging to this organization."""
  services(includeDeleted: Boolean): [Graph!]! @deprecated(reason: "Use graphs field instead")
}

"""An invitation for a user to join an organization."""
type AccountInvitation {
  """An accepted invitation cannot be used anymore"""
  acceptedAt: Timestamp

  """Who accepted the invitation"""
  acceptedBy: User

  """Time the invitation was created"""
  createdAt: Timestamp!

  """Who created the invitation"""
  createdBy: User
  email: String!
  id: ID!

  """Last time we sent an email for the invitation"""
  lastSentAt: Timestamp

  """Access role for the invitee"""
  role: UserPermission!
}

"""The membership association between a user and an organization."""
type AccountMembership {
  """The timestamp when the user was added to the organization."""
  createdAt: Timestamp!

  """The user's role within the organization'."""
  role: UserPermission!

  """The user that belongs to the organization."""
  user: User!
}

type OrganizationMutation {
  """Send an invitation to join the organization by E-mail"""
  invite(email: String!, role: UserPermission): AccountInvitation

  """Create or update a custom session length for an org"""
  setCustomSessionLength(sessionDurationInSeconds: Int!): Int!

  """Update a user's role within an organization"""
  updateUserRole(role: UserPermission!, userID: ID!): User
  createGraph(graphType: GraphType!, hiddenFromUninvitedNonAdmin: Boolean!, id: ID!, title: String!, variantCreationConfig: VariantCreationConfig): GraphCreationResult!

  """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!
}

"""Filter options available when searching affected queries for a check."""
input AffectedQueriesFilterInput {
  """Filter by a keyword to match against the query's operation name or ID."""
  search: String

  """
  Filter affected queries by one or more statuses.
  
  For example, use `[BROKEN]` to return only queries that are broken,
  or `[BROKEN, POTENTIALLY_AFFECTED]` to include queries that are broken OR possibly affected.
  """
  status: [AffectedQueryStatus!]
}

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
}

enum AffectedQueryStatus {
  """This query will break as a result of the changes in this check."""
  BROKEN

  """This query is valid but may be affected by the changes in this check."""
  POTENTIALLY_AFFECTED

  """
  This query is affected by the changes, but was marked as safe in a previous check.
  """
  SAFE

  """
  This query is affected by the changes, but was ignored in a previous check
  """
  IGNORED
}

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

"""
Exactly one of the inputs must be set in a build configuration.
Which build configuration type is set will determine the type
of variant that is created. Existing variants of a given type
cannot be updated in-place to be of a different type.
"""
input BuildConfigInput {
  """
  This list will contain any directives that should get passed through to the api schema from the core schema. Anything included in this list will appear in the consumer facing schema
  """
  apiDirectivePassThrough: [String!]!

  """if buildPipelineTrack is null use the graph default"""
  buildPipelineTrack: BuildPipelineTrack
  composition: CompositionConfigInput
  contract: ContractConfigInput
}

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

"""Contains the details of an executed build that failed."""
type BuildFailure {
  errorCount: Int!

  """A list of all errors that occurred during the failed build."""
  errorMessages: [BuildError!]!
}

union BuildInput = CompositionBuildInput | FilterBuildInput

enum BuildPipelineTrack {
  FED_1_0
  FED_1_1
  FED_2_0
  FED_2_1
  FED_2_10
  FED_2_11
  FED_2_3
  FED_2_4
  FED_2_5
  FED_2_6
  FED_2_7
  FED_2_8
  FED_2_9
}

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!
}

"""
The result of a failed call to PersistedQueryListMutation.delete due to linked variant(s).
"""
type CannotDeleteLinkedPersistedQueryListError implements Error {
  message: String!
}

type CannotModifyOperationBodyError implements Error {
  message: String!
}

"""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

  """Short description of the change"""
  shortDescription: String
}

"""
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

  """The default value of an input object field was changed."""
  INPUT_OBJECT_FIELD_DEFAULT_VALUE_CHANGE

  """A default value was added to an input object field."""
  INPUT_OBJECT_FIELD_DEFAULT_VALUE_ADDED

  """The default value of an input object field was removed."""
  INPUT_OBJECT_FIELD_DEFAULT_VALUE_REMOVED

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

"""Graph-level configuration of checks."""
type CheckConfiguration {
  """
  How submitted build input diffs are handled when they match (or don't) a Proposal
  """
  proposalChangeMismatchSeverity: ProposalChangeMismatchSeverity!

  """ID of the check configuration"""
  id: ID!

  """Graph that this check configuration belongs to"""
  graphID: ID!

  """Operations to ignore during validation"""
  excludedOperations: [ExcludedOperation!]!

  """Clients to ignore during validation"""
  excludedClients: [ClientFilter!]!

  """Operation names to ignore during validation"""
  excludedOperationNames: [OperationNameFilter]

  """Variant overrides for validation"""
  includedVariants: [String!]!

  """Whether to run Linting during schema checks."""
  enableLintChecks: Boolean!

  """Time when check configuration was created"""
  createdAt: Timestamp!

  """Time when check configuration was last updated"""
  updatedAt: Timestamp!

  """Identity of the last user to update the check configuration"""
  updatedBy: Identity

  """
  Only check operations from the last <timeRangeSeconds> seconds.
  The default is 7 days (604,800 seconds).
  """
  timeRangeSeconds: Long!

  """
  Minimum number of requests within the window for an operation to be considered.
  """
  operationCountThreshold: Int!

  """
  Number of requests within the window for an operation to be considered, relative to
  total request count. Expected values are between 0 and 0.05 (minimum 5% of
  total request volume)
  """
  operationCountThresholdPercentage: Float!

  """Default configuration to include operations on the base variant."""
  includeBaseVariant: Boolean!

  """
  During operation checks, if this option is enabled, it evaluates a check
  run against zero operations as a pass instead of a failure.
  """
  downgradeStaticChecks: Boolean!

  """
  During operation checks, if this option is enabled, the check will not fail or
  mark any operations as broken/changed if the default value has changed, only
  if the default value is removed completely.
  """
  downgradeDefaultValueChange: Boolean!
  enableCustomChecks: Boolean!
}

"""Filter options available when listing checks."""
input CheckFilterInput {
  """A list of git commiters. For cli triggered checks, this is the author."""
  authors: [String!]

  """
  A list of actors triggering this check. For non cli triggered checks, this is the Studio User / author.
  """
  createdBy: [ActorInput!]
  branches: [String!]
  subgraphs: [String!]
  status: CheckFilterInputStatusOption
  variants: [String!]
  ids: [String!]
}

"""
Options for filtering CheckWorkflows by status
This should always match CheckWorkflowStatus
"""
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 | RateLimitExceededError

"""
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 automatically by a Proposal update."""
  isProposal: Boolean

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

enum CheckStepStatus {
  FAILURE
  SUCCESS
}

"""An individual diagnostic violation of a custom check task."""
type CheckViolation {
  """
  The schema coordinate of this rule violation as defined by RFC:
  		https://github.com/graphql/graphql-wg/blob/main/rfcs/SchemaCoordinates.md
  		Optional for violations that aren't specific to a single schema element
  """
  coordinate: String

  """The violation level for the rule."""
  level: ViolationLevel!

  """
  A human-readable message describing the rule violation, rendered as markdown in Apollo Studio. Maximum length: 512 characters.
  """
  message: String!

  """
  The rule being violated. This is used to group multiple violations together in Studio. Max character length is 128.
  """
  rule: String!

  """
  The start and end position in the file of the rule violation. Used to display rule violations in the context of your schema diff.
  """
  sourceLocations: [FileLocation!]
}

"""An individual diagnostic violation of a custom check task."""
input CheckViolationInput {
  """
  The schema coordinate of this rule violation as defined by RFC:
  		https://github.com/graphql/graphql-wg/blob/main/rfcs/SchemaCoordinates.md
  		Optional for violations that aren't specific to a single schema element
  """
  coordinate: String

  """The violation level for the rule."""
  level: ViolationLevel!

  """
  A human-readable message describing the rule violation, rendered as markdown in Apollo Studio. Maximum length: 512 characters.
  """
  message: String!

  """
  The rule being violated. This is used to group multiple violations together in Studio. Max character length is 128.
  """
  rule: String!

  """
  The start and end position in the file of the rule violation. Used to display rule violations in the context of your schema diff.
  """
  sourceLocations: [FileLocationInput!]
}

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

  """
  If this check was created by rerunning, the original check workflow that was rerun.
  """
  rerunOf: CheckWorkflow

  """Checks created by re-running this check, most recent first."""
  reruns(limit: Int! = 20): [CheckWorkflow!]

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

"""A client to be filtered."""
type ClientFilter {
  """Name of the client is required."""
  name: String!

  """Version string of the client."""
  version: String
}

"""
Options to filter by client reference ID, client name, and client version.
If passing client version, make sure to either provide a client reference ID or client name.
"""
input ClientFilterInput {
  """name of the client set by the user and reported alongside metrics"""
  name: String!

  """version of the client set by the user and reported alongside metrics"""
  version: String
}

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

  """Ignored"""
  referenceID: ID
  version: String
}

"""Invalid input error"""
type CloudInvalidInputError {
  """Argument related to the error"""
  argument: String!

  """Location of the error"""
  location: String

  """Reason for the error"""
  reason: String!
}

"""Cloud Router tiers"""
enum CloudTier {
  """Serverless tier"""
  SERVERLESS

  """Dedicated tier"""
  DEDICATED

  """Enterprise Cloud tier"""
  ENTERPRISE
}

"""Validation result"""
union CloudValidationResult = CloudValidationSuccess | InvalidInputErrors | InternalServerError

"""Config validation success"""
type CloudValidationSuccess {
  message: String!
}

enum CommentStatus {
  DELETED
  OPEN
  RESOLVED
}

type ComposeAndFilterPreviewBuildResults {
  """The API schema document/SDL generated from composition/filtering."""
  apiSchemaDocument: String!

  """
  The supergraph core schema document/SDL generated from composition/filtering.
  """
  supergraphSchemaDocument: String!
}

type ComposeAndFilterPreviewComposeError {
  """
  A machine-readable error code. See https://www.apollographql.com/docs/federation/errors/for more info.
  """
  code: String

  """The step at which composition failed."""
  failedStep: String

  """Source locations related to the error."""
  locations: [SourceLocation!]

  """A human-readable message describing the error."""
  message: String!
}

type ComposeAndFilterPreviewComposeFailure {
  """The list of errors from failed composition."""
  composeErrors: [ComposeAndFilterPreviewComposeError!]!
}

type ComposeAndFilterPreviewFilterError {
  """
  The step at which filtering failed. See https://www.apollographql.com/docs/studio/contracts/#contract-errors for more info.
  """
  failedStep: String

  """A human-readable message describing the error."""
  message: String!
}

type ComposeAndFilterPreviewFilterFailure {
  """The results from successful composition."""
  composeResults: ComposeAndFilterPreviewBuildResults!

  """The list of errors from failed filtering."""
  filterErrors: [ComposeAndFilterPreviewFilterError!]!
}

union ComposeAndFilterPreviewResult = ComposeAndFilterPreviewComposeFailure | ComposeAndFilterPreviewFilterFailure | ComposeAndFilterPreviewSuccess

input ComposeAndFilterPreviewSubgraphChange {
  """
  The info being changed in the named subgraph. If null, indicates that the named
   subgraph should be removed prior to composition.
  """
  info: ComposeAndFilterPreviewSubgraphChangeInfo

  """The name of the subgraph being changed."""
  name: String!
}

input ComposeAndFilterPreviewSubgraphChangeInfo {
  """
  The routing URL of the subgraph. If a subgraph with the same name exists, then this
  field can be null to indicate the existing subgraph's info should be used; using
  null otherwise results in an error.
  """
  routingUrl: String

  """
  The schema document/SDL of the subgraph. If a subgraph with the same name exists,
  then this field can be null to indicate the existing subgraph's info should be
  used; using null otherwise results in an error.
  """
  schemaDocument: String
}

type ComposeAndFilterPreviewSuccess {
  """The results from successful composition."""
  composeResults: ComposeAndFilterPreviewBuildResults!

  """
  The results from successful filtering, or null if filtering was skipped.
  """
  filterResults: ComposeAndFilterPreviewBuildResults
}

"""
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!

  """Whether an implementingService was updated as part of this mutation"""
  wasUpdated: Boolean!

  """All subgraphs that were created from this mutation"""
  subgraphsCreated: [String!]!

  """All subgraphs that were updated from this mutation"""
  subgraphsUpdated: [String!]!

  """The Launch result part of this subgraph publish."""
  launch: Launch

  """
  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!
}

input CompositionConfigInput {
  subgraphs: [SubgraphInput!]!
}

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

input ContractConfigInput {
  baseGraphRef: String!
  filterConfigInput: FilterConfigInput!
}

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
}

type Coordinate {
  byteOffset: Int!
  column: Int!
  line: Int!
}

"""Contains the supergraph and API schemas generated by composition."""
type CoreSchema {
  """The composed API schema document."""
  apiDocument: GraphQLDocument!

  """
  The API schema document's SHA256 hash, represented as a hexadecimal string.
  """
  apiHash: String!

  """The composed supergraph schema document."""
  coreDocument: GraphQLDocument!

  """
  The supergraph schema document's SHA256 hash, represented as a hexadecimal string.
  """
  coreHash: String!
}

union CreateOperationCollectionResult = NotFoundError | OperationCollection | PermissionError | ValidationError

"""
The result of a successful call to GraphMutation.createPersistedQueryList.
"""
type CreatePersistedQueryListResult {
  persistedQueryList: PersistedQueryList!
}

"""
The result/error union returned by GraphMutation.createPersistedQueryList.
"""
union CreatePersistedQueryListResultOrError = CreatePersistedQueryListResult | PermissionError

"""An error that occurs when creating a proposal fails."""
type CreateProposalError implements Error {
  """The error's details."""
  message: String!
}

input CreateProposalInput {
  description: String
  displayName: String!
  sourceVariantName: String!
}

union CreateProposalResult = CreateProposalError | GraphVariant | PermissionError | ValidationError

input CustomCheckCallbackInput {
  """
  Sets the status of your check task. Setting this status to FAILURE will cause the entire check workflow to fail.
  """
  status: CheckStepStatus!

  """The ID of the custom check task, provided in the webhook payload."""
  taskId: ID!

  """The violations found by your check task. Max length is 1000"""
  violations: [CheckViolationInput!]

  """
  The ID of the workflow that the custom check task is a member of, provided in the webhook payload.
  """
  workflowId: ID!
}

"""Result of a custom check task callback mutation."""
union CustomCheckCallbackResult = CustomCheckResult | PermissionError | TaskError | ValidationError

"""Custom check configuration detailing webhook integration."""
type CustomCheckConfiguration {
  channel: CustomCheckWebhookChannel!
  id: ID!
}

"""Result of a custom check configuration update mutation."""
union CustomCheckConfigurationResult = CustomCheckConfiguration | PermissionError | ValidationError

type CustomCheckResult {
  violations: [CheckViolation!]!
}

type CustomCheckTask implements CheckWorkflowTask {
  graphID: ID!
  id: ID!
  result: CustomCheckResult
  completedAt: Timestamp
  createdAt: Timestamp!
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
}

"""Configuration of a webhook integration for a custom check."""
type CustomCheckWebhookChannel {
  """The time when this CustomCheckWebhookChannel was created."""
  createdAt: Timestamp!

  """
  The Identity that created this CustomCheckWebhookChannel. null if the Identity has been deleted.
  """
  createdBy: Identity

  """The ID for this webhook channel"""
  id: ID!

  """
  The last time this subscription was updated, if never updated will be the createdAt time.
  """
  lastUpdatedAt: Timestamp!

  """
  The Identity that last updated this CustomCheckWebhookChannel, or the creator if no one has updated. null if the Identity has been deleted.
  """
  lastUpdatedBy: Identity

  """Whether or not a secret token has been set on this channel."""
  secretTokenIsSet: Boolean!

  """The URL to send the webhook to."""
  url: String!

  """
  The variant name if this channel is only configured for a specific variant. If null, this configuration applies to all variants.
  """
  variant: String
}

"""
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 = DeleteOperationCollectionSuccess | PermissionError

type DeleteOperationCollectionSuccess {
  sandboxOwner: User
  variants: [GraphVariant!]!
}

"""The result of a successful call to PersistedQueryListMutation.delete."""
type DeletePersistedQueryListResult {
  graph: Graph!
}

"""The result/error union returned by PersistedQueryListMutation.delete."""
union DeletePersistedQueryListResultOrError = CannotDeleteLinkedPersistedQueryListError | DeletePersistedQueryListResult | 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!
}

enum DownstreamLaunchInitiation {
  """
  Initiate the creation of downstream launches associated with this subgraph publication asynchronously.
  The resulting API response may not provide specific details about triggered downstream launches.
  """
  ASYNC

  """
  Initiate the creation of downstream Launches associated with this subgraph publication synchronously.
  Use this option to ensure that any downstream launches will be started before the publish mutation returns.
  Note that this does not require launches to complete, but it does ensure that the downstream launch IDs are
  available to be queried from a `CompositionAndUpsertResult`.
  """
  SYNC
}

"""GraphQL Error"""
interface Error {
  message: String!
}

"""Excluded operation for a graph."""
type ExcludedOperation {
  """Operation ID to exclude from schema check."""
  ID: ID!
}

"""Option to filter by operation ID."""
input ExcludedOperationInput {
  """Operation ID to exclude from schema check."""
  ID: ID!
}

"""
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 deleted. Null if it wasn't deleted.
  """
  deletedAt: 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!
}

type FileCoordinate {
  byteOffset: Int!
  column: Int!
  line: Int!
}

input FileCoordinateInput {
  byteOffset: Int!
  column: Int!
  line: Int!
}

type FileLocation {
  end: FileCoordinate!
  start: FileCoordinate!
  subgraphName: String
}

input FileLocationInput {
  end: FileCoordinateInput!
  start: FileCoordinateInput!
  subgraphName: String
}

"""
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!]!
}

"""
Represents a diff between two versions of a schema as a flat list of changes
"""
type FlatDiff {
  diff: [FlatDiffItem!]!
  id: ID!
  summary: FlatDiffSummary!
}

type FlatDiffAddArgument implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddDirective implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddDirectiveUsage implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddEnum implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddEnumValue implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddField implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddImplementation implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddInput implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddInterface implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddObject implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddScalar implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddSchemaDefinition implements FlatDiffItem {
  type: FlatDiffType!
}

type FlatDiffAddSchemaDirectiveUsage implements FlatDiffItem & FlatDiffItemValue {
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddSchemaRootOperation implements FlatDiffItem & FlatDiffItemRootType & FlatDiffItemValue {
  rootType: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddUnion implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffAddUnionMember implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffAddValidLocation implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffChangeArgumentDefault implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemNullableValue {
  coordinate: String!
  type: FlatDiffType!
  value: String
}

type FlatDiffChangeDescription implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemNullableValue {
  coordinate: String!
  type: FlatDiffType!
  value: String
}

type FlatDiffChangeDirectiveRepeatable implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
  value: Boolean!
}

type FlatDiffChangeInputFieldDefault implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemNullableValue {
  coordinate: String!
  type: FlatDiffType!
  value: String
}

type FlatDiffChangeSchemaDescription implements FlatDiffItem & FlatDiffItemNullableValue {
  type: FlatDiffType!
  value: String
}

interface FlatDiffItem {
  type: FlatDiffType!
}

interface FlatDiffItemCoordinate implements FlatDiffItem {
  coordinate: String!
  type: FlatDiffType!
}

interface FlatDiffItemNullableValue implements FlatDiffItem {
  type: FlatDiffType!
  value: String
}

interface FlatDiffItemRootType implements FlatDiffItem {
  rootType: String!
  type: FlatDiffType!
}

interface FlatDiffItemValue implements FlatDiffItem {
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveArgument implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveDirective implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveDirectiveUsage implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveEnum implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveEnumValue implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveField implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveImplementation implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveInput implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveInterface implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveObject implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveScalar implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveSchemaDefinition implements FlatDiffItem {
  type: FlatDiffType!
}

type FlatDiffRemoveSchemaDirectiveUsage implements FlatDiffItem & FlatDiffItemValue {
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveSchemaRootOperation implements FlatDiffItem & FlatDiffItemRootType {
  rootType: String!
  type: FlatDiffType!
}

type FlatDiffRemoveUnion implements FlatDiffItem & FlatDiffItemCoordinate {
  coordinate: String!
  type: FlatDiffType!
}

type FlatDiffRemoveUnionMember implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

type FlatDiffRemoveValidLocation implements FlatDiffItem & FlatDiffItemCoordinate & FlatDiffItemValue {
  coordinate: String!
  type: FlatDiffType!
  value: String!
}

union FlatDiffResult = FlatDiff | NotFoundError

"""Represents a summary of a diff between two versions of a schema."""
type FlatDiffSummary {
  directive: FlatDiffTypeSummary!
  enum: FlatDiffTypeSummary!
  input: FlatDiffTypeSummary!
  interface: FlatDiffTypeSummary!
  object: FlatDiffTypeSummary!
  scalar: FlatDiffTypeSummary!
  schema: FlatDiffTypeSummary!
  union: FlatDiffTypeSummary!
}

enum FlatDiffType {
  ADD_ARGUMENT
  ADD_DIRECTIVE
  ADD_DIRECTIVE_USAGE
  ADD_ENUM
  ADD_ENUM_VALUE
  ADD_FIELD
  ADD_IMPLEMENTATION
  ADD_INPUT
  ADD_INTERFACE
  ADD_OBJECT
  ADD_SCALAR
  ADD_SCHEMA_DEFINITION
  ADD_SCHEMA_DIRECTIVE_USAGE
  ADD_SCHEMA_ROOT_OPERATION
  ADD_UNION
  ADD_UNION_MEMBER
  ADD_VALID_LOCATION
  CHANGE_ARGUMENT_DEFAULT
  CHANGE_DESCRIPTION
  CHANGE_INPUT_FIELD_DEFAULT
  CHANGE_REPEATABLE
  CHANGE_SCHEMA_DESCRIPTION
  REMOVE_ARGUMENT
  REMOVE_DIRECTIVE
  REMOVE_DIRECTIVE_USAGE
  REMOVE_ENUM
  REMOVE_ENUM_VALUE
  REMOVE_FIELD
  REMOVE_IMPLEMENTATION
  REMOVE_INPUT
  REMOVE_INTERFACE
  REMOVE_OBJECT
  REMOVE_SCALAR
  REMOVE_SCHEMA_DEFINITION
  REMOVE_SCHEMA_DIRECTIVE_USAGE
  REMOVE_SCHEMA_ROOT_OPERATION
  REMOVE_UNION
  REMOVE_UNION_MEMBER
  REMOVE_VALID_LOCATION
}

type FlatDiffTypeSummary {
  add: Int!
  change: Int!
  remove: Int!
  typeCount: Int!
}

interface GeneralProposalComment implements ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

type GitContext {
  commit: ID
}

"""This is stored with a schema when it is uploaded"""
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!
}

"""The timing details for the build step of a launch."""
type GraphCreationError {
  message: String!
}

union GraphCreationResult = GraphCreationError | Graph

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

type GraphQLDoc {
  graph: Graph!
  hash: ID!
  source: GraphQLDocument!
}

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

enum GraphType {
  CLASSIC
  CLOUD_SUPERGRAPH
  SELF_HOSTED_SUPERGRAPH
}

"""A graph variant"""
type GraphVariant {
  """The variant's global identifier in the form `graphID@variant`."""
  id: ID!

  """The variant's name (e.g., `staging`)."""
  name: String!

  """Router associated with this graph variant"""
  router: Router

  """Validate router configuration for this graph variant"""
  validateRouter(config: RouterConfigInput!): CloudValidationResult!
  checkConfiguration: VariantCheckConfiguration!

  """Custom check configuration for this graph."""
  customCheckConfiguration: CustomCheckConfiguration

  """The graph that this variant belongs to."""
  graph: Graph!

  """
  Compose and filter preview contract schema built from this source variant.
  """
  composeAndFilterPreview(
    """
    The filter configuration of a hypothetical contract variant on this variant. Null indicates that filtering should be skipped/not run, in which case ComposeAndFilterPreviewSuccess.filterResults will be null.
    """
    filterConfig: FilterConfigInput

    """
    Any hypothetical changes desired for the subgraphs of this variant. Null is the same as the empty list.
    """
    subgraphChanges: [ComposeAndFilterPreviewSubgraphChange!]
  ): ComposeAndFilterPreviewResult

  """
  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

  """Time the variant was created"""
  createdAt: Timestamp!

  """Federation version this variant uses"""
  federationVersion: String

  """Represents whether this variant is a Proposal."""
  isProposal: Boolean

  """
  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

  """Retrieve a launch for this variant by ID."""
  launch(id: ID!): Launch

  """
  A list of launches metadata ordered by date, asc or desc depending on orderBy. The maximum limit is 100.
  """
  launchSummaries(limit: Int! = 100, offset: Int! = 0, orderBy: LaunchHistoryOrder! = CREATED_DESC): [LaunchSummary!]

  """
  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

  """
  Returns a list of the top operations reported for this variant within a given time range. This API is rate limited,
  and will return an error if too many requests are made for a graph.
  """
  topOperationsReport(
    """Optional filters to refine the results"""
    filter: TopOperationsReportVariantFilterInput

    """
    The starting timestamp for the report.
    
    - Must be in the format: 2025-01-01T00:00:00Z (ISO 8601).
      - Must be within the last 549 days.
      - The duration between 'from' and 'to' must not exceed 31 days.
    """
    from: Timestamp!

    """Maximum number of records to return (default: 10)"""
    limit: Int! = 10

    """Sorting criteria for the report"""
    orderBy: TopOperationsReportOrderByInput

    """
    The ending timestamp for the report.
    
    - Must be in the format: 2025-01-01T08:00:00Z (ISO 8601).
    - Must be at least 6 hours from the current time.
      - The duration between 'from' and 'to' must not exceed 31 days.
    """
    to: Timestamp!
  ): [TopOperationRecord!]!

  """
  The default collection MCP servers will use if no explicit collection is provided. Auto-creates a collection if it does not exist.
  """
  mcpDefaultCollection: McpDefaultCollectionResult!

  """
  A list of the saved [operation collections](https://www.apollographql.com/docs/studio/explorer/operation-collections/) associated with this variant.
  This field accepts up to 400 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  operationCollections: [OperationCollection!]!

  """The Persisted Query List linked to this variant, if any."""
  persistedQueryList: PersistedQueryList

  """
  Returns the proposal-related fields for this graph variant if the variant is a proposal; otherwise, returns null. This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  proposal: Proposal

  """
  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!]

  """
  A list of the subgraphs that have been published to since the variant was created.
  Does not include subgraphs that were created & deleted since the variant was created.
  
  TODO: @deprecated(reason: "use GraphVariant.updatedSubgraphsSinceCreation instead")
  """
  updatedSubgraphs: [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
  routerConfig: String
}

"""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 {
  """Gets the router attached to a graph variant"""
  router: RouterMutation

  """
  Callback mutation for submitting custom check results once your validation has run.
  Results are returned with the SUCCESS or FAILURE of your validations, the task and workflow ids
  to associate results, with and an optional list of violations to provide more details to users.
  The Schema Check will wait for this response for 10 minutes and not complete until the results are returned.
  After 10 minutes have passed without a callback request being received, the task will be marked as timed out.
  """
  customCheckCallback(input: CustomCheckCallbackInput!): CustomCheckCallbackResult!
  setCustomCheckConfiguration(input: SetCustomCheckConfigurationInput!): CustomCheckConfigurationResult!

  """
  _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.
  
  Rate limited to 3000 per min. Schema checks cannot be performed on contract variants.
  """
  submitCheckSchemaAsync(input: CheckSchemaAsyncInput!): CheckRequestResult!

  """
   _Asynchronously_ kicks off composition and operation checks for all proposed subgraphs schema changes 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.
  
  Rate limited to 3000 per min. Subgraph checks cannot be performed on contract variants.
  """
  submitMultiSubgraphCheckAsync(input: MultiSubgraphCheckAsyncInput!): 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.
  
  Rate limited to 3000 per min. Subgraph checks cannot be performed on contract variants.
  """
  submitSubgraphCheckAsync(input: SubgraphCheckAsyncInput!): CheckRequestResult!
  updateCheckConfigurationCustomChecks(
    """
    Whether custom checks is enabled for this variant. If the useGraphSettings argument is true, this argument is ignored. If the useGraphSettings argument is false and this argument is null, defaults to false.
    """
    enableCustomChecks: Boolean

    """
    When this argument is true, indicates that graph-level configuration is used for this variant setting.
    """
    useGraphSettings: Boolean!
  ): VariantCheckConfiguration!
  updateCheckConfigurationDowngradeChecks(
    """
    During operation checks, when this argument is true, the check will not fail or
      mark any operations as broken/changed if the default value has changed, only
      if the default value is removed completely. If this argument is null, the
    value is unchanged.
    """
    downgradeDefaultValueChange: Boolean

    """
    During operation checks, when this argument is true, it evaluates a check
      run against zero operations as a pass instead of a failure. If this argument
    is null, the value is unchanged.
    """
    downgradeStaticChecks: Boolean

    """
    When this argument is true, indicates that graph-level configuration is used for this variant
    setting.
    """
    useGraphSettings: Boolean!
  ): VariantCheckConfiguration!
  updateCheckConfigurationDownstreamVariants(
    """
    During downstream checks, this variant's check workflow will wait for all downstream check
    workflows for <blockingDownstreamVariants> variants to complete, and if any of them fail, then
    this variant's check workflow will fail. If this argument is null, the value is unchanged.
    """
    blockingDownstreamVariants: [String!]
  ): VariantCheckConfiguration!
  updateCheckConfigurationEnableOperationsCheck(enabled: Boolean!): VariantCheckConfiguration
  updateCheckConfigurationExcludedClients(
    """
    When this argument is true, indicates that graph-level configuration is appended to the
    variant-level configuration.
    """
    appendGraphSettings: Boolean!

    """
    During operation checks, ignore clients matching any of the <excludedClients> filters. If this
    argument is null, the value is unchanged.
    """
    excludedClients: [ClientFilterInput!]
  ): VariantCheckConfiguration!
  updateCheckConfigurationExcludedOperations(
    """
    When this argument is true, indicates that graph-level configuration is appended to the
    variant-level configuration.
    """
    appendGraphSettings: Boolean!

    """
    During operation checks, ignore operations matching any of the <excludedOperationNames>
    filters. If this argument is null, the value is unchanged.
    """
    excludedOperationNames: [OperationNameFilterInput!]

    """
    During operation checks, ignore operations matching any of the <excludedOperations> filters. If
    this argument is null, the value is unchanged.
    """
    excludedOperations: [OperationInfoFilterInput!]
  ): VariantCheckConfiguration!
  updateCheckConfigurationIncludedVariants(
    """
    During operation checks, fetch operations from the metrics data for <includedVariants>
    variants. If the useGraphSettings argument is true, this argument is ignored. If the
    useGraphSettings argument is false and this argument is null, the value is unchanged (if
    useGraphSettings was previously true, the default of a list containing just this variant is
    used instead).
    """
    includedVariants: [String!]

    """
    When this argument is true, indicates that graph-level configuration is used for this variant
    setting.
    """
    useGraphSettings: Boolean!
  ): VariantCheckConfiguration!
  updateCheckConfigurationProposalChangeMismatchSeverity(
    """
    How submitted build input diffs are handled when they match (or don't) a Proposal at the variant level.
    """
    proposalChangeMismatchSeverity: ProposalChangeMismatchSeverity

    """
    When this argument is true, indicates that graph-level configuration is used for this variant setting.
    """
    useGraphSettings: Boolean @deprecated(reason: "Graph-level configuration is no longer supported")
  ): VariantCheckConfiguration!
  updateCheckConfigurationTimeRange(
    """
    During operation checks, ignore operations that executed less than <operationCountThreshold>
    times in the time range. If the useGraphSettings argument is true, this argument is ignored. If
    the useGraphSettings argument is false and this argument is null, the value is unchanged (if
    useGraphSettings was previously true, the default of 1 is used instead).
    """
    operationCountThreshold: Int

    """
    Duration operation checks, ignore operations that constituted less than
    <operationCountThresholdPercentage>% of the operations in the time range. Expected values are
    between 0% and 5%. If the useGraphSettings argument is true, this argument is ignored. If the
    useGraphSettings argument is false and this argument is null, the value is unchanged (if
    useGraphSettings was previously true, the default of 0% is used instead).
    """
    operationCountThresholdPercentage: Float

    """
    During operation checks, fetch operations from the last <timeRangeSeconds> seconds. If the
    useGraphSettings argument is true, this argument is ignored. If the useGraphSettings argument
    is false and this argument is null, the value is unchanged (if useGraphSettings was previously
    true, the default of 7 days is used instead).
    """
    timeRangeSeconds: Long

    """
    When this argument is true, indicates that graph-level configuration is used for this variant
    setting.
    """
    useGraphSettings: Boolean!
  ): VariantCheckConfiguration!

  """
  Updates the [federation version](https://www.apollographql.com/docs/graphos/reference/router/federation-version-support) of this variant
  """
  updateVariantFederationVersion(version: BuildPipelineTrack!): GraphVariant

  """
  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

  """
  Links a specified PersistedQueryList to the variant of the parent GraphVariantMutation.
  """
  linkPersistedQueryList(persistedQueryListId: ID!): LinkPersistedQueryListResultOrError!

  """
  Unlinks a specified PersistedQueryList from the variant of the parent GraphVariantMutation.
  """
  unlinkPersistedQueryList: UnlinkPersistedQueryListResultOrError!

  """
  Provides access to mutation fields for modifying a GraphOS Schema Proposal, if this GraphVariant is a proposal variant; else returns NotFoundError. Learn more at https://www.apollographql.com/docs/graphos/delivery/schema-proposals
  """
  proposal: ProposalMutationResult!
  updateURL(url: String): GraphVariant

  """Delete the variant."""
  delete: GraphVariantDeletionResult!
  upsertRouterConfig(configuration: String!): UpsertRouterResult
}

"""
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 view launch history
  """
  canQueryLaunches: 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!

  """
  If this variant is a Proposal, will match the Proposal.canEditProposal field (can the current user can edit this Proposal either by authorship or role level). False if this GraphVariant is not a Proposal.
  """
  canEditProposal: 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 {
  asActor: Actor!
  id: ID!
  name: String!
  email: String
  accounts: [Organization!]!
}

"""
Generic server error. This should only ever return 'internal server error' as a message
"""
type InternalServerError implements Error {
  """Message related to the internal error"""
  message: 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!
}

"""Generic input error"""
type InvalidInputErrors implements Error {
  errors: [CloudInvalidInputError!]!
  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!

  """Cloud Router order for this launch ID"""
  order: OrderOrError!
  orders: [Order!]!

  """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

  """
  The launch immediately prior to this one. If successOnly is true, returns the most recent successful launch; if false, returns the most recent launch, regardless of success. If no such previous launch exists, returns null.
  """
  previousLaunch(
    """Controls if only successful launches are returned. Defaults to false."""
    successOnly: Boolean
  ): Launch

  """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

  """
  Returns the proposal revision associated with this launch, if it exists. This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  proposalRevision: ProposalRevision
}

enum LaunchHistoryOrder {
  CREATED_ASC
  CREATED_DESC
}

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

"""
Key information representing the complete process of making a set of updates to a deployed graph variant.
"""
type LaunchSummary {
  """The timestamp when the launch was approved."""
  approvedAt: Timestamp

  """
  Identifier of the associated build for this launch. This value is null until the build is initiated.
  """
  buildID: ID

  """
  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!

  """The ID of the launch's associated graph."""
  graphId: String!

  """The name of the launch's associated variant."""
  graphVariant: String!

  """The unique identifier for this launch."""
  id: ID!

  """
  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!]!

  """
  The launch's status. If a launch is superseded, its status remains `LAUNCH_INITIATED`. To check for a superseded launch, use `supersededAt`.
  """
  status: LaunchStatus!
}

"""
The result/error union returned by GraphVariantMutation.linkPersistedQueryList.
"""
union LinkPersistedQueryListResultOrError = ListNotFoundError | PermissionError | VariantAlreadyLinkedError

type LintCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  graphID: ID!
  id: ID!
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
  result: LintResult
}

"""A single rule violation."""
type LintDiagnostic {
  """The schema coordinate of this diagnostic."""
  coordinate: String!

  """The graph's configured level for the rule."""
  level: LintDiagnosticLevel!

  """The message describing the rule violation."""
  message: String!

  """The lint rule being violated."""
  rule: LintRule!

  """The human readable position in the file of the rule violation."""
  sourceLocations: [Location!]!
}

"""The severity level of an lint result."""
enum LintDiagnosticLevel {
  ERROR
  IGNORED
  WARNING
}

"""The result of linting a schema."""
type LintResult {
  """The set of lint rule violations found in the schema."""
  diagnostics: [LintDiagnostic!]!

  """Stats generated from the resulting diagnostics."""
  stats: LintStats!
}

enum LintRule {
  ALL_ELEMENTS_REQUIRE_DESCRIPTION
  CONTACT_DIRECTIVE_MISSING
  DEFINED_TYPES_ARE_UNUSED
  DEPRECATED_DIRECTIVE_MISSING_REASON
  DIRECTIVE_COMPOSITION
  DIRECTIVE_NAMES_SHOULD_BE_CAMEL_CASE
  DOES_NOT_PARSE
  ENUM_PREFIX
  ENUM_SUFFIX
  ENUM_USED_AS_INPUT_WITHOUT_SUFFIX
  ENUM_USED_AS_OUTPUT_DESPITE_SUFFIX
  ENUM_VALUES_SHOULD_BE_SCREAMING_SNAKE_CASE
  FIELD_NAMES_SHOULD_BE_CAMEL_CASE
  FROM_SUBGRAPH_DOES_NOT_EXIST
  INCONSISTENT_ARGUMENT_PRESENCE
  INCONSISTENT_BUT_COMPATIBLE_ARGUMENT_TYPE
  INCONSISTENT_BUT_COMPATIBLE_FIELD_TYPE
  INCONSISTENT_DEFAULT_VALUE_PRESENCE
  INCONSISTENT_DESCRIPTION
  INCONSISTENT_ENTITY
  INCONSISTENT_ENUM_VALUE_FOR_INPUT_ENUM
  INCONSISTENT_ENUM_VALUE_FOR_OUTPUT_ENUM
  INCONSISTENT_EXECUTABLE_DIRECTIVE_LOCATIONS
  INCONSISTENT_EXECUTABLE_DIRECTIVE_PRESENCE
  INCONSISTENT_EXECUTABLE_DIRECTIVE_REPEATABLE
  INCONSISTENT_INPUT_OBJECT_FIELD
  INCONSISTENT_INTERFACE_VALUE_TYPE_FIELD
  INCONSISTENT_NON_REPEATABLE_DIRECTIVE_ARGUMENTS
  INCONSISTENT_OBJECT_VALUE_TYPE_FIELD
  INCONSISTENT_RUNTIME_TYPES_FOR_SHAREABLE_RETURN
  INCONSISTENT_TYPE_SYSTEM_DIRECTIVE_LOCATIONS
  INCONSISTENT_TYPE_SYSTEM_DIRECTIVE_REPEATABLE
  INCONSISTENT_UNION_MEMBER
  INPUT_ARGUMENT_NAMES_SHOULD_BE_CAMEL_CASE
  INPUT_TYPE_SUFFIX
  INTERFACE_PREFIX
  INTERFACE_SUFFIX
  MERGED_NON_REPEATABLE_DIRECTIVE_ARGUMENTS
  NO_EXECUTABLE_DIRECTIVE_INTERSECTION
  NULLABLE_PATH_VARIABLE
  OBJECT_PREFIX
  OBJECT_SUFFIX
  OVERRIDDEN_FIELD_CAN_BE_REMOVED
  OVERRIDE_DIRECTIVE_CAN_BE_REMOVED
  OVERRIDE_MIGRATION_IN_PROGRESS
  QUERY_DOCUMENT_DECLARATION
  RESTY_FIELD_NAMES
  TAG_DIRECTIVE_USES_UNKNOWN_NAME
  TYPE_NAMES_SHOULD_BE_PASCAL_CASE
  TYPE_PREFIX
  TYPE_SUFFIX
  UNUSED_ENUM_TYPE
}

"""
Stats generated from linting a schema against the graph's linter configuration.
"""
type LintStats {
  """Total number of lint errors."""
  errorsCount: Int!

  """Total number of lint rules ignored."""
  ignoredCount: Int!

  """Total number of lint rules violated."""
  totalCount: Int!

  """Total number of lint warnings."""
  warningsCount: Int!
}

"""
The result of a failed call to GraphVariantMutation.linkPersistedQueryList when the specified list can't be found.
"""
type ListNotFoundError implements Error {
  listId: ID!
  message: String!
}

type Location {
  end: Coordinate
  start: Coordinate
  subgraphName: String
}

"""Level of the log entry"""
enum LogLevel {
  """Debug log entry"""
  DEBUG

  """Informational log entry"""
  INFO

  """Warning log entry"""
  WARN

  """Error log entry"""
  ERROR
}

"""Order log message"""
type LogMessage {
  """Timestamp in UTC"""
  timestamp: DateTime!

  """Log message contents"""
  message: String!

  """Log level"""
  level: LogLevel!
}

"""Long type"""
scalar Long

union McpDefaultCollectionResult = OperationCollection | PermissionError

"""
Input type to provide when running schema checks against multiple subgraph changes asynchronously for a federated supergraph.
"""
input MultiSubgraphCheckAsyncInput {
  """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 automatically by a Proposal update."""
  isProposal: Boolean

  """If `true`, the check was initiated by Apollo Sandbox."""
  isSandbox: Boolean!

  """
  The source variant that this check should use the operations check configuration from
  """
  sourceVariant: String

  """The changed subgraph schemas to check."""
  subgraphsToCheck: [SubgraphSdlCheckInput]!

  """
  The user that triggered this check. If null, defaults to authContext to determine user.
  """
  triggeredBy: ActorInput
}

"""GraphQL mutations"""
type Mutation {
  """
  Provides access to mutation fields for modifying a an organization with the provided ID.
  """
  organization(id: ID!): OrganizationMutation

  """
  Provides access to mutation fields for modifying an Apollo user with the
  provided ID.
  """
  user(id: ID!): UserMutation

  """
  Provides access to mutation fields for modifying a Studio graph with the provided ID.
  """
  graph(id: ID!): GraphMutation

  """
  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. This field accepts up to 200 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  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

  """
  Provides access to mutation fields for modifying a GraphOS Schema Proposals with the provided ID. Learn more at https://www.apollographql.com/docs/graphos/delivery/schema-proposals
  """
  proposal(id: ID!): ProposalMutationResult! @deprecated(reason: "Use GraphVariantMutation.proposal instead")
}

"""
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/). This fields on this type accepts up to 200 requests per minute combined. This rate may be temporarily adjusted based on system conditions.
"""
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!
}

type OperationInfoFilter {
  id: String!
}

input OperationInfoFilterInput {
  id: String!
}

"""Operation name filter configuration for a graph."""
type OperationNameFilter {
  """name of the operation by the user and reported alongside metrics"""
  name: String!
  version: 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 OperationsCheckConfiguration {
  """
  During operation checks, if this option is enabled, the check will not fail or
   mark any operations as broken/changed if the default value has changed, only
   if the default value is removed completely.
  """
  downgradeDefaultValueChange: Boolean!

  """
  During operation checks, if this option is enabled, it evaluates a check
  run against zero operations as a pass instead of a failure.
  """
  downgradeStaticChecks: Boolean!

  """
  During the operations check, ignore clients matching any of the <excludedClients> filters.
  """
  excludedClients: [ClientFilter!]!

  """
  During the operations check, ignore operations matching any of the <excludedOperationNames> filters.
  """
  excludedOperationNames: [OperationNameFilter!]!

  """
  During the operations check, ignore operations matching any of the <excludedOperations> filters.
  """
  excludedOperations: [OperationInfoFilter!]!

  """The start of the time range for the operations check."""
  fromNormalized: Timestamp!

  """
  During the operations check, fetch operations from the metrics data for <includedVariants>
  variants.
  """
  includedVariants: [String!]!

  """
  During the operations check, ignore operations that executed less than <operationCountThreshold>
  times in the time range.
  """
  operationCountThreshold: Int!

  """
  Duration the operations check, ignore operations that constituted less than
  <operationCountThresholdPercentage>% of the operations in the time range.
  """
  operationCountThresholdPercentage: Float!

  """The end of the time range for the operations check."""
  toNormalized: Timestamp!
}

input OperationsCheckConfigurationOverridesInput {
  """
  During the operations check, ignore clients matching any of the <excludedClients> filters.
  Providing null will use variant- or graph-level settings instead.
  """
  excludedClients: [ClientFilterInput!]

  """
  During the operations check, ignore operations matching any of the <excludedOperationNames>
  filters. Providing null will use variant- or graph-level settings instead.
  """
  excludedOperationNames: [OperationNameFilterInput!]

  """
  During the operations check, ignore operations matching any of the <excludedOperations> filters.
  Providing null will use variant- or graph-level settings instead.
  """
  excludedOperations: [OperationInfoFilterInput!]

  """
  The start of the time range for the operations check, expressed as an offset from the time the
  check request is received (in seconds) or an ISO-8601 timestamp. Providing null here and
  useMaxRetention as false will use variant- or graph-level settings instead. It is an error to
  provide a non-null value here and useMaxRetention as true.
  """
  from: String

  """
  During the operations check, fetch operations from the metrics data for <includedVariants>
  variants. Providing null will use variant- or graph-level settings instead.
  """
  includedVariants: [String!]

  """
  During the operations check, ignore operations that executed less than <operationCountThreshold>
  times in the time range. Providing null will use variant- or graph-level settings instead.
  """
  operationCountThreshold: Int

  """
  During the operations check, ignore operations that executed less than <operationCountThreshold>
  times in the time range. Expected values are between 0% and 5%. Providing null will use variant-
  or graph-level settings instead.
  """
  operationCountThresholdPercentage: Float

  """
  The end of the time range for the operations check, expressed as an offset from the time the
  check request is received (in seconds) or an ISO-8601 timestamp. Providing null here and
  useMaxRetention as false will use variant- or graph-level settings instead. It is an error to
  provide a non-null value here and useMaxRetention as true.
  """
  to: String

  """
  During the operations check, use the maximum time range allowed by the graph's plan's retention.
  Providing false here and from/to as null will use variant- or graph-level settings instead. It is
  an error to provide true here and from/to as non-null.
  """
  useMaxRetention: Boolean! = false
}

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!

  """Total number of schema changes, excluding any truncation."""
  totalNumberOfChanges: Int!

  """
  Indicates whether the changes for this operation check were truncated due to their large quantity.
  """
  areChangesTruncated: Boolean!

  """Operations affected by all changes in diff"""
  affectedQueries(
    """The maximum number of affected queries to return. Must be 50 or fewer."""
    limit: Int

    """
    How many items to skip before starting to return results.
    For example, with `limit: 10` and `offset: 10`, you get items 11–20.
    """
    offset: Int

    """Optional filters to narrow down which affected queries are returned."""
    filter: AffectedQueriesFilterInput
  ): [AffectedQuery!]

  """Returns an affected operation and its changes for this check"""
  affectedQuery(id: ID!): AffectedQuery

  """
  Number of affected operations that are neither marked as SAFE or IGNORED.
  """
  numberOfAffectedOperations: Int!

  """
  Total number of affected operations including ones marked SAFE or IGNORED.
  """
  totalNumberOfAffectedOperations: Int!
  createdAt: Timestamp!
}

type OperationsCheckTask implements CheckWorkflowTask {
  completedAt: Timestamp
  createdAt: Timestamp!
  graphID: ID!
  id: ID!

  """
  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
  status: CheckWorkflowTaskStatus!
  targetURL: String
  workflow: CheckWorkflow!
}

enum OperationType {
  MUTATION
  QUERY
  SUBSCRIPTION
}

"""Cloud Router order"""
type Order {
  """Order identifier"""
  id: ID!

  """Order type"""
  orderType: OrderType!

  """Order status"""
  status: OrderStatus!

  """Reason for ERRORED or ROLLING_BACK orders"""
  reason: String

  """
  Completion percentage of the order (between 0 and 100)
  
  This will only return data for IN_PROGRESS, COMPLETED, or SUPERSEDED states
  """
  completionPercentage: Int

  """When this Order was created"""
  createdAt: NaiveDateTime!

  """Last time this Order was updated"""
  updatedAt: NaiveDateTime
  logs: [LogMessage!]!

  """Router associated with this Order"""
  router: Router!
}

enum Ordering {
  ASCENDING
  DESCENDING
}

"""Return an Order or an error"""
union OrderOrError = Order

"""Represents the different status for an order"""
enum OrderStatus {
  """New Order in progress"""
  PENDING

  """Order was successfully completed"""
  COMPLETED

  """
  Order is currently rolling back
  
  All resources created as part of this Order are being deleted
  """
  ROLLING_BACK

  """Order was unsuccessful"""
  ERRORED

  """
  Order has been superseded by another, more recent order
  
  This can happen if two update orders arrive in close succession and we already
  started to process the newer order first.
  """
  SUPERSEDED
}

"""Represents the different types of order"""
enum OrderType {
  """Create a new Cloud Router"""
  CREATE_ROUTER

  """Destroy an existing Cloud Router"""
  DESTROY_ROUTER

  """Update an existing Cloud Router"""
  UPDATE_ROUTER
}

"""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 ParentChangeProposalComment implements ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!

  """
  true if the schemaCoordinate this comment is on doesn't exist in the diff between the most recent revision & the base sdl
  """
  outdated: Boolean!
  replies: [ReplyChangeProposalComment!]!
  replyCount: Int!
  schemaCoordinate: String!

  """
  '#@!api!@#' for api schema, '#@!supergraph!@#' for supergraph schema, subgraph otherwise
  """
  schemaScope: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

type ParentGeneralProposalComment implements GeneralProposalComment & ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!
  replies: [ReplyGeneralProposalComment!]!
  replyCount: Int!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

"""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 {
  """
  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

  """
  Contents of the partial schema in SDL syntax, but may reference types
  that aren't defined in this document
  """
  sdl: String
}

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

"""Information about the act of publishing operations to the list"""
type PersistedQueriesPublish {
  operationCounts: PersistedQueriesPublishOperationCounts!
}

type PersistedQueriesPublishOperationCounts {
  """The number of new operations added to the list by this publish."""
  added: Int!

  """
  The number of operations included in this publish whose metadata and body were unchanged from the previous list revision.
  """
  identical: Int!

  """The number of operations removed from the list by this publish."""
  removed: Int!

  """
  The number of operations in this list that were not mentioned by this publish.
  """
  unaffected: Int!

  """
  The number of operations whose metadata or body were changed by this publish.
  """
  updated: Int!
}

"""Full identifier for an operation in a Persisted Query List."""
input PersistedQueryIdInput {
  """
  An optional client name to associate with the operation. Two operations with the same ID but different client names are treated as distinct operations. An operation with the same ID and a null client name is treated as a distinct operation as well.
  """
  clientName: String

  """
  An opaque identifier for this operation. For a given client name, this should map uniquely to an operation body; editing the body should generally result in a new ID. Apollo's tools generally use the lowercase hex SHA256 of the operation body.
  """
  id: ID!
}

"""Operations to be published to the Persisted Query List."""
input PersistedQueryInput {
  """
  The GraphQL document for this operation, including all necessary fragment definitions.
  """
  body: GraphQLDocument!

  """
  An optional client name to associate with the operation. Two operations with the same ID but different client names are treated as distinct operations.
  """
  clientName: String

  """
  An opaque identifier for this operation. This should map uniquely to an operation body; editing the body should generally result in a new ID. Apollo's tools generally use the lowercase hex SHA256 of the operation body.
  """
  id: ID!

  """
  A name for the operation. Typically this is the name of the actual GraphQL operation in the body. This does not need to be unique within a Persisted Query List; as a client project evolves and its operations change, multiple operations with the same name (but different body and id) can be published.
  """
  name: String!

  """The operation's type."""
  type: OperationType!
}

"""A Persisted Query List for a graph."""
type PersistedQueryList {
  """The current build of this PQL."""
  currentBuild: PersistedQueryListBuild!

  """The immutable ID for this Persisted Query List."""
  id: ID!

  """All variants linked to this Persisted Query List, if any."""
  linkedVariants: [GraphVariant!]!

  """The list's name; can be changed and does not need to be unique."""
  name: String!
}

"""
Information about a particular revision of the list, as produced by a particular publish.
"""
type PersistedQueryListBuild {
  """The persisted query list that this build built."""
  list: PersistedQueryList!

  """
  The chunks that made up this build. We do not commit to keeping the full contents of older revisions indefinitely, so this may be null for suitably old revisions.
  """
  manifestChunks: [PersistedQueryListManifestChunk!]

  """Information about the publish operation that created this build."""
  publish: PersistedQueriesPublish!

  """
  The revision of this Persisted Query List. Revision 0 is the initial empty list; each publish increments the revision by 1.
  """
  revision: Int!

  """
  The total number of operations in the list after this build. Compare to PersistedQueriesPublish.operationCounts.
  """
  totalOperationsInList: Int!
}

type PersistedQueryListManifestChunk {
  """
  An immutable identifier for this particular chunk of a PQL. The contents referenced by this ID will never change.
  """
  id: ID!

  """
  The chunk can be downloaded from any of these URLs, which might be transient.
  """
  urls: [String!]!
}

type PersistedQueryListMutation {
  """Deletes this Persisted Query List."""
  delete: DeletePersistedQueryListResultOrError!

  """
  Updates this Persisted Query List by publishing a set of operations and removing other operations. Operations not mentioned remain in the list unchanged.
  """
  publishOperations(
    allowOverwrittenOperations: Boolean
    operations: [PersistedQueryInput!]
    remove: [PersistedQueryIdInput!]

    """Deprecated. Use `remove` instead, which allows specifying clientName."""
    removeOperations: [ID!]
  ): PublishOperationsResultOrError!

  """
  Updates the name and/or description of the specified Persisted Query List.
  """
  updateMetadata(description: String, name: String): UpdatePersistedQueryListMetadataResultOrError!
}

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

type Proposal {
  """
  A list of the activities for this proposal.
  If first and last are not specified, defaults to 25. If one is specified there is a max allowed value of 50.
  """
  activities(after: String, before: String, first: Int, last: Int): ProposalActivityConnection!

  """The variant this Proposal is under the hood."""
  backingVariant: GraphVariant!

  """
  Can the current user can edit THIS proposal, either by authorship or role level
  """
  canEditProposal: Boolean!
  createdAt: Timestamp!

  """
  null if user is deleted, or if user removed from org
  and others in the org no longer have access to this user's info
  """
  createdBy: Identity

  """The description of this Proposal."""
  description: String!
  descriptionUpdatedAt: Timestamp
  descriptionUpdatedBy: Identity
  displayName: String!

  """
  A flag indicating if changes have been detected on the source variant. Will be false if proposal was created prior to the pull upstream feature release on Nov 15, 2024.
  """
  hasUpstreamChanges: Boolean!
  id: ID!
  implementedChanges: [ProposalImplementedChange!]!

  """
  True if only some of the changes in this proposal are currently published to the implementation variant
  """
  isPartiallyImplemented: Boolean!
  latestRevision: ProposalRevision!
  reviews: [ProposalReview!]!

  """The variant this Proposal was cloned/sourced from."""
  sourceVariant: GraphVariant!
  status: ProposalStatus!
  updatedAt: Timestamp!
  updatedBy: Identity
}

type ProposalActivity {
  activity: ProposalActivityAction
  createdAt: Timestamp!
  createdBy: Identity
  id: ID!
  target: ProposalActivityTarget
}

enum ProposalActivityAction {
  """
  When the system changes a Proposal's status back to OPEN from APPROVED when approvals drop below min approvals.
  """
  APPROVAL_WITHDRAWN

  """
  When the system changes a Proposal's status back to OPEN from APPROVED when a change is made after a proposal or review is approved.
  """
  APPROVAL_WITHDRAWN_ON_PUBLISH

  """When a user manually sets a Proposal to Close"""
  CLOSE_PROPOSAL

  """When a Comment is added to a Proposal."""
  COMMENT_ADDED

  """When a subgraph in a Proposal is deleted."""
  DELETE_SUBGRAPH

  """
  When a diff in a Proposal publish is found to already be in the Implementation target variant that fully implements the Proposal. Status of the Proposal will change to IMPLEMENTED.
  """
  FULLY_IMPLEMENTED_PROPOSAL_ORIGIN

  """ When a diff in an Implementation variant publish is found in a Proposal that fully implements the Proposal. Status of the Proposal will change to IMPLEMENTED.
  """
  FULLY_IMPLEMENTED_VARIANT_ORIGIN

  """
  When the system changes a Proposal's status to APPROVED when the min approvals have been met.
  """
  MET_MIN_APPROVALS_PROPOSAL

  """When a user manually sets a Proposal to Open"""
  OPEN_PROPOSAL

  """
  When a diff in a Proposal publish is found to already be in the Implementation target variant that partially implements the Proposal. Does not change the status of the Proposal, but isPartiallyImplemented will return true.
  """
  PARTIALLY_IMPLEMENTED_PROPOSAL_ORIGIN

  """
  When a diff in an Implementation variant publish is found in a Proposal that partially implements the Proposal. Does not change the status of the Proposal, but isPartiallyImplemented will return true.
  """
  PARTIALLY_IMPLEMENTED_VARIANT_ORIGIN

  """When a new revision is published to subgraphs in a Proposal."""
  PUBLISH_SUBGRAPHS

  """When a Proposal is moved to DRAFT from another status not on creation."""
  RETURN_TO_DRAFT_PROPOSAL

  """When a Review is added to a Proposal."""
  REVIEW_ADDED
}

type ProposalActivityConnection {
  edges: [ProposalActivityEdge!]
  nodes: [ProposalActivity!]!
  pageInfo: PageInfo!
  totalCount: Int!
}

type ProposalActivityEdge {
  """A cursor for use in pagination."""
  cursor: String!
  node: ProposalActivity
}

union ProposalActivityTarget = ParentChangeProposalComment | ParentGeneralProposalComment | Proposal | ProposalFullImplementationProposalOrigin | ProposalFullImplementationVariantOrigin | ProposalPartialImplementationProposalOrigin | ProposalPartialImplementationVariantOrigin | ProposalReview | ProposalRevision

enum ProposalChangeMismatchSeverity {
  ERROR
  OFF
  WARN
}

interface ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

enum ProposalCoverage {
  FULL
  NONE
  OVERRIDDEN
  PARTIAL
  PENDING
}

type ProposalFullImplementationProposalOrigin {
  """
  the time this Proposal became implemented in the implementation target variant.
  """
  createdAt: Timestamp!
  id: ID!

  """
  the diff that was matched between the Proposal and the implementation target variant. TODO to deserialize this back into a DiffItem NEBULA-2726
  """
  jsonDiff: [String!]!

  """
  Revision containing a diff that fully implements this Proposal in the implementation target variant.
  """
  revision: ProposalRevision!

  """the target variant this Proposal became implemented in."""
  variant: GraphVariant!
}

type ProposalFullImplementationVariantOrigin {
  """
  the time this Proposal became implemented in the implementation target variant.
  """
  createdAt: Timestamp!
  id: ID!

  """
  the diff that was matched between the Proposal and the implementation target variant. TODO to deserialize this back into a DiffItem NEBULA-2726
  """
  jsonDiff: [String!]!

  """
  launch containing a diff that fully implements this Proposal in the implementation target variant. null if user does not have access to launches
  """
  launch: Launch

  """the target variant this Proposal became implemented in."""
  variant: GraphVariant!
}

type ProposalImplementedChange {
  diffItem: FlatDiffItem!
  launchId: ID!
  subgraph: String!
}

"""
Mutations for editing GraphOS Schema Proposals. See documentation at https://www.apollographql.com/docs/graphos/delivery/schema-proposals
"""
type ProposalMutation {
  """
  The GraphOS Schema Proposal being modified by this mutation. See documentation at https://www.apollographql.com/docs/graphos/delivery/schema-proposals
  """
  proposal: Proposal

  """
  This mutation creates a new revision of a proposal by publishing multiple subgraphs, saving the summary and recording a diff. If composition is successful, this will update running routers. See the documentation at https://www.apollographql.com/docs/graphos/delivery/schema-proposals/creation/#save-revisions This field accepts up to 500 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  publishSubgraphs(input: PublishProposalSubgraphsInput!): PublishProposalSubgraphResult!

  """
  Updates the description of this Proposal variant. Returns ValidationError if description exceeds max length of 10k characters.
  """
  updateDescription(input: UpdateDescriptionInput!): UpdateProposalResult!

  """
  Update the title of this proposal. This field accepts up to 200 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  updateDisplayName(displayName: String!): UpdateProposalResult!

  """
  Update the list of requested reviewers for this proposal. This field accepts up to 500 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  updateRequestedReviewers(input: UpdateRequestedReviewersInput!): UpdateRequestedReviewersResult!

  """
  Update the status of this proposal. This field accepts up to 500 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  updateStatus(status: ProposalStatus!): UpdateProposalResult!
}

union ProposalMutationResult = NotFoundError | PermissionError | ProposalMutation | ValidationError

type ProposalPartialImplementationProposalOrigin {
  """
  the time this Proposal became partially implemented in the implementation target variant.
  """
  createdAt: Timestamp!
  id: ID!

  """
  the diff that was matched between the Proposal and the implementation target variant. TODO to deserialize this back into a DiffItem NEBULA-2726
  """
  jsonDiff: [String!]!

  """
  Revision containing a diff that partially implements this Proposal in the implementation target variant.
  """
  revision: ProposalRevision!

  """the target variant this Proposal became partially implemented in."""
  variant: GraphVariant!
}

type ProposalPartialImplementationVariantOrigin {
  """
  the time this Proposal became partially implemented in the implementation target variant.
  """
  createdAt: Timestamp!
  id: ID!

  """
  the diff that was matched between the Proposal and the implementation target variant. TODO to deserialize this back into a DiffItem NEBULA-2726
  """
  jsonDiff: [String!]!

  """
  launch containing a diff that partially implements this Proposal in the implementation target variant. null if user does not have access to launches
  """
  launch: Launch

  """the target variant this Proposal became partially implemented in."""
  variant: GraphVariant!
}

type ProposalReview {
  comment: ReviewProposalComment
  createdAt: Timestamp!
  createdBy: Identity
  decision: ReviewDecision!
  id: ID!
  isDismissed: Boolean!
  updatedAt: Timestamp
  updatedBy: Identity
}

type ProposalRevision {
  id: ID!

  """
  Latest composition ID of the proposal's source variant at the time this revision was created.
  """
  mergeBaseCompositionId: ID

  """
  The schema publish of the proposal's source variant at the time this revision was created. Null if the launch is PENDING.
  """
  mergeBaseSchemaPublish: SchemaPublication

  """
  The schema publish for this revision. Null while the launch is PENDING.
  """
  schemaPublish: SchemaPublication

  """
  On publish, checks are triggered on a proposal automatically. However, if an error occurred triggering a check on publish, we skip attempting the check to avoid blocking the publish from succeeding. This is the only case this field would be null.
  """
  checkWorkflow: CheckWorkflow
  createdAt: Timestamp!
  createdBy: Identity
  isMerge: Boolean!
  launch: Launch

  """null if this is the first revision"""
  previousRevision: ProposalRevision
  summary: String!
}

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

  """The results of this proposal check were overridden"""
  didOverrideProposalsCheckTask: Boolean!

  """
  Diff items in this Check task. Will be empty list if hasExceededMaxDiffs is true.
  """
  diffs: [ProposalsCheckTaskDiff!]!

  """
  Indicates if the number of diffs in this check has exceeded the maximum allowed. null if this check was run before this field was added.
  """
  hasExceededMaxDiffs: Boolean

  """True if this Proposal check passed with warnings, otherwise false."""
  hasWarnings: Boolean!

  """
  Indicates the level of coverage a check's changeset is in approved Proposals. PENDING while Check is still running.
  """
  proposalCoverage: ProposalCoverage!

  """
  Proposals with their state at the time the check was run associated to this check task.
  """
  relatedProposalResults: [RelatedProposalResult!]!

  """
  The configured severity at the time the check was run. If the check failed, this is the severity that should be shown. While this Check is PENDING defaults to Service's severityLevel.
  """
  severityLevel: ProposalChangeMismatchSeverity!
}

"""A diff item in this Check Task and their related Proposals."""
type ProposalsCheckTaskDiff {
  """A diff item in this Check Task."""
  diffItem: FlatDiffItem!

  """If this diff item is associated with an approved Proposal."""
  hasApprovedProposal: Boolean!

  """Proposals associated with this diff."""
  relatedProposalResults: [RelatedProposalResult!]!

  """The subgraph this diff belongs to."""
  subgraph: String!
}

"""Filtering options for list of proposals."""
input ProposalsFilterInput {
  """
  Only include proposals that were created with these variants as a base.
  """
  sourceVariants: [String!]

  """Only include proposals of a certain status."""
  status: [ProposalStatus!]

  """Only include proposals that have updated these subgraph names"""
  subgraphs: [String!]
}

"""
Proposals, limited & offset based on Service.proposals & the total count
"""
type ProposalsResult {
  """The proposals on this graph."""
  proposals: [Proposal!]!

  """The total number of proposals on this graph"""
  totalCount: Int!
}

enum ProposalStatus {
  APPROVED
  CLOSED
  DRAFT
  IMPLEMENTED
  OPEN
}

"""Filtering options for graph connections."""
input ProposalVariantsFilter {
  """
  Only include proposals that were created with these variants as a base.
  """
  sourceVariants: [String!]

  """Only include proposals of a certain status."""
  status: [ProposalStatus!]

  """Only include proposals that have updated these subgraph names"""
  subgraphs: [String!]
}

"""
Proposal variants, limited & offset based on Service.proposalVariants & the total count
"""
type ProposalVariantsResult {
  """The total number of proposal variants on this graph"""
  totalCount: Int!
  variants: [GraphVariant!]!
}

"""
The result of a successful call to PersistedQueryListMutation.publishOperations.
"""
type PublishOperationsResult {
  """The build created by this publish operation."""
  build: PersistedQueryListBuild!

  """
  Returns `true` if no changes were made by this publish (and no new revision was created). Otherwise, returns `false`.
  """
  unchanged: Boolean!
}

"""
The result/error union returned by PersistedQueryListMutation.publishOperations.
"""
union PublishOperationsResultOrError = CannotModifyOperationBodyError | PermissionError | PublishOperationsResult

union PublishProposalSubgraphResult = NotFoundError | PermissionError | Proposal | ValidationError

input PublishProposalSubgraphsInput {
  gitContext: GitContextInput
  previousLaunchId: ID!
  revision: String!
  subgraphInputs: [PublishSubgraphsSubgraphInput!]!
  summary: String!
}

input PublishSubgraphsSubgraphInput {
  activePartialSchema: PartialSchemaInput!
  name: String!
  url: String
}

"""Queries defined by this subgraph"""
type Query {
  """
  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 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 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. This field accepts up to 400 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  operationCollection(id: ID!): OperationCollectionResult!

  """
  This field accepts up to 400 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  operationCollectionEntries(collectionEntryIds: [ID!]!): [OperationCollectionEntry!]!

  """
  Returns a proposal by its ID. This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  proposal(id: ID!): Proposal
}

"""
An error that occurs when the rate limit on this operation has been exceeded.
"""
type RateLimitExceededError {
  """The error message."""
  message: String!
}

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

"""A Proposal related to a Proposal Check Task."""
type RelatedProposalResult {
  """
  The latest revision at the time the check was run, defaults to current revision if nothing found for time of the check.
  """
  latestRevisionAtCheck: ProposalRevision!

  """
  The Proposal related to the check. State may have changed since the Check was run.
  """
  proposal: Proposal!

  """
  The status of the Proposal at the time the check was run, defaults to current state if nothing found for time of the check.
  """
  statusAtCheck: ProposalStatus!
}

union RemoveOperationCollectionEntryResult = OperationCollection | PermissionError

type ReplyChangeProposalComment implements ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!

  """
  true if the schemaCoordinate this comment is on doesn't exist in the diff between the most recent revision & the base sdl
  """
  outdated: Boolean!
  schemaCoordinate: String!

  """
  '#@!api!@#' for api schema, '#@!supergraph!@#' for supergraph schema, subgraph otherwise
  """
  schemaScope: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

type ReplyGeneralProposalComment implements GeneralProposalComment & ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

input RerunAsyncInput {
  sourceVariant: String
}

enum ReviewDecision {
  APPROVED
  NOT_APPROVED
}

type ReviewProposalComment implements ProposalComment {
  createdAt: Timestamp!

  """null if the user is deleted"""
  createdBy: Identity
  id: ID!
  message: String!
  status: CommentStatus!

  """null if never updated"""
  updatedAt: Timestamp
}

type Router {
  """Return the GraphVariant associated with this Router"""
  graphVariant: GraphVariant

  """Date when the Cloud Router was created"""
  createdAt: NaiveDateTime!

  """
  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
  
  This will be null if the Cloud Router is in a deleted status.
  """
  routerVersion: RouterVersion

  """
  Cloud Router version applied for the next launch
  
  If this value is not null, any subsequent launch will use this version instead of the
  current one. This can happen when a new STABLE version is available, but we could not
  automatically update this Cloud Router, for example due to configuration issues.
  """
  nextRouterVersion: RouterVersion

  """
  URL where the Cloud Router can be found
  
  This will be null if the Cloud Router is in a deleted status
  """
  routerUrl: String @deprecated(reason: "use Router.endpoints instead")

  """
  Custom URLs that can be used to reach the Cloud Router
  
  This will be null if the Cloud Router is in a deleted status or does not support custom
  domains.
  """
  customDomains: [String!] @deprecated(reason: "use Router.endpoints instead")

  """Set of endpoints that can be used to reach a Cloud Router"""
  endpoints: RouterEndpoints!

  """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!]!

  """
  Number of Graph Compute Units (GCUs) associated with this Cloud Router
  
  This value is not present for Cloud Routers on the `SERVERLESS` tier.
  """
  gcus: Int
}

"""Router configuration input"""
input RouterConfigInput {
  """Router version for the Cloud Router"""
  routerVersion: String

  """Configuration for the Cloud Router"""
  routerConfig: String

  """Graph composition ID, also known as launch ID"""
  graphCompositionId: String

  """
  Number of GCUs allocated for the Cloud Router
  
  This is ignored for serverless Cloud Routers
  """
  gcus: Int
}

"""
List of endpoints for Cloud Router

## Endpoint states

If a Router is in the `DELETED` state, all the fields on this object will return `null`.

For all other states, this table list all the possible valid states, and the mutations that can
be performed on them.

| Default Enabled? | Primary Endpoint | Custom Endpoints | Allowed endpoint mutations                                           |
| Yes              | Default          | null             | N/A (this Router does not support custom endpoints)                  |
| Yes              | Default          | []               | addCustomDomain, enableDefaultEndpoint, resetPrimaryEndpoint         |
| Yes              | Default          | ["1", "2", "3"]  | addCustomDomain, enableDefaultEndpoint, removeCustomDomain("1", "2", or "3"), resetPrimaryEndpoint, setPrimaryEndpoint ("1", "2", or "3") |
| Yes              | Custom 1         | ["1", "2", "3"]  | addCustomDomain, disableDefaultEndpoint, enableDefaultEndpoint, removeCustomDomain("2" or "3"), resetPrimaryEndpoint, setPrimaryEndpoint ("1", "2", or "3") |
| No               | Custom 1         | ["1", "2", "3"]  | addCustomDomain, disableDefaultEndpoint, enableDefaultEndpoint, removeCustomDomain("2" or "3"), setPrimaryEndpoint ("1", "2", or "3") |
"""
type RouterEndpoints {
  """
  Default Cloud Router endpoint
  
  This is null if the cloud router is in a deleted state.
  """
  default: String

  """
  Whether the default Cloud Router endpoint is enabled
  
  If the default endpoint is not enabled (`false`), this Cloud Router cannot receive traffic
  on the default endpoint.
  
  This is null if the cloud router is in a deleted state.
  """
  defaultEnabled: Boolean

  """
  Set of custom Cloud Router endpoints
  
  This is null if the cloud router is in a deleted state, or if it does not support
  custom endpoints.
  """
  custom: [String!]

  """
  Primary Cloud Router endpoint
  
  This is null if the cloud router is in a deleted state.
  """
  primary: String
}

"""Represents the possible outcomes of an endpoint mutation"""
union RouterEndpointsResult = RouterEndpointsSuccess | InvalidInputErrors | InternalServerError

"""Successe branch of  an addEndpoint or removeEndpoint mutation"""
type RouterEndpointsSuccess {
  endpoints: RouterEndpoints!
}

type RouterLicense {
  """
  RFC 8037 Ed25519 JWT signed representation of sibling fields. Restricted to internal services only.
  """
  jwt: String!
}

"""Represents the possible outcomes of a setGcus mutation"""
union RouterGcusResult = RouterGcusSuccess | InvalidInputErrors | InternalServerError

"""Success branch of a setGcus mutation"""
type RouterGcusSuccess {
  order: Order!
}

type RouterMutation {
  """Set secrets for this Cloud Router"""
  setSecrets(input: RouterSecretsInput!): RouterSecretsResult!

  """Set the number of GCUs associated with this Router"""
  setGcus(gcus: Int!): RouterGcusResult!

  """Add a custom domain for this Cloud Router"""
  addCustomDomain(customDomain: String!): RouterEndpointsResult!

  """Remove a custom domain for this Cloud Router"""
  removeCustomDomain(customDomain: String!): RouterEndpointsResult!
}

"""User input for a RouterSecrets mutation"""
input RouterSecretsInput {
  """Secrets to create or update"""
  secrets: [SecretInput!]

  """Secrets to remove"""
  unsetSecrets: [String!]
}

"""Represents the possible outcomes of a RouterSecrets mutation"""
union RouterSecretsResult = RouterSecretsSuccess | InvalidInputErrors | InternalServerError

"""Success branch of a RouterSecrets mutation."""
type RouterSecretsSuccess {
  secrets: [Secret!]!
}

"""Current status of Cloud Routers"""
enum RouterStatus {
  """Cloud Router is not yet provisioned"""
  CREATING

  """Cloud Router is running, but currently being updated"""
  UPDATING

  """
  Cloud Router is running, but currently being deleted
  
  This is the only mutation state that doesn't support rollback. If we fail to
  delete a Router, the workflows are configured to stop and keep the router into
  the Deleting status.
  """
  DELETING

  """
  Current order is rolling back to the last known good state
  
  After a RollingBack state, a Router can move either into Running state (from a
  Update order) or Deleted (from a Create order).
  
  If we fail to roll back, the workflows are configured to stop and keep the router
  into the RollingBack status.
  """
  ROLLING_BACK

  """Current router is running and able to server requests"""
  RUNNING

  """
  Router has been put to sleep. This state should only be possible for Serverless routers
  """
  SLEEPING

  """Router has been deleted"""
  DELETED
}

type RouterUpsertFailure {
  message: String!
}

"""Router Version"""
type RouterVersion {
  """Version identifier"""
  version: String!

  """Core version identifier"""
  core: String!

  """Build number"""
  build: String!

  """Status of a router version"""
  status: Status!

  """Config version for this router version"""
  configVersion: String!

  """
  JSON schema for validating the router configuration for this router version
  """
  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
}

"""Cloud Router secret"""
type Secret {
  """When the secret was created"""
  createdAt: DateTime!

  """Name of the secret"""
  name: String!

  """Hash of the secret"""
  hash: String!
}

"""Input for creating or updating secrets"""
input SecretInput {
  """Name of the secret"""
  name: String!

  """
  Value for that secret
  
  This can only be used for input, as it is not possible to retrieve the value of secrets.
  """
  value: 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

  """Short description of the change"""
  shortDescription: String
}

"""
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

  """Provides a view of the graph as an `Actor` type."""
  asActor: Actor!

  """The graph's globally unique identifier."""
  id: ID!
  name: String!

  """Describes the permissions that the active user has for this graph."""
  roles: GraphRoles

  """A list of the graph API keys that are active for this graph."""
  apiKeys: [GraphApiKey!]

  """Permissions of the current user in this graph."""
  myRole: UserPermission

  """A list of the variants for this graph."""
  variants: [GraphVariant!]!

  """Get a check workflow for this graph by its ID"""
  checkWorkflow(id: ID!): CheckWorkflow

  """
  When this is true, this graph will be hidden from non-admin members of the org who haven't been explicitly assigned a
  role on this graph.
  """
  hiddenFromUninvitedNonAdminAccountMembers: Boolean!

  """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

  """The Persisted Query List associated with this graph with the given ID."""
  persistedQueryList(id: ID!): PersistedQueryList

  """Get check configuration for this graph."""
  checkConfiguration: CheckConfiguration

  """
  Returns the default reviewers for this graph. This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  defaultProposalReviewers: [Identity]!

  """
  Diffs the sdls at the oldSdlHash and newSdlHash, returning a FlatDiffResult. This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  flatDiff(newSdlHash: SHA256, oldSdlHash: SHA256): FlatDiffResult!

  """
  A list of the proposals for this graph sorted by created at date.
  limit defaults to 25 and has an allowed max of 50, offset defaults to 0.
  This field accepts up to 1000 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  proposals(filterBy: ProposalsFilterInput, limit: Int, offset: Int): ProposalsResult!

  """Get a GraphQL document by hash"""
  doc(hash: SHA256): GraphQLDoc

  """
  Get GraphQL documents by hash, max up to 100 can be requested per query. This field accepts up to 120 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  docs(hashes: [SHA256!]!): [GraphQLDoc]

  """Get a GraphQL document by hash"""
  document(hash: SHA256): GraphQLDocument @deprecated(reason: "Use doc instead")

  """
  Count checkWorkflows for the given filter. Used for paginating with checkWorkflows.
  """
  totalCheckWorkflowCount(filter: CheckFilterInput): Int!

  """
  Get check workflows for this graph ordered by creation time, most recent first.
  """
  checkWorkflows(limit: Int! = 100, offset: Int! = 0, filter: CheckFilterInput): [CheckWorkflow!]!
}

"""
Provides access to mutation fields for managing Studio graphs and subgraphs.
"""
type GraphMutation {
  setCustomCheckConfiguration(input: SetCustomCheckConfigurationInput!): CustomCheckConfigurationResult!

  """
  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

  """
  Soft delete a graph. Data associated with the graph is not permanently deleted; Apollo support can undo.
  """
  delete: Void

  """Undelete a soft deleted graph."""
  undelete: Graph

  """Update hiddenFromUninvitedNonAdminAccountMembers"""
  updateHiddenFromUninvitedNonAdminAccountMembers(hiddenFromUninvitedNonAdminAccountMembers: Boolean!): Graph

  """
  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

  """Lint a single schema using the graph's linter configuration."""
  lintSchema(
    """
    The schema to diff rule violations against, if not provided the full set of rule violations will be returned for the proposed sdl.
    """
    baseSdl: String

    """The schema to lint."""
    sdl: String!
  ): LintResult!

  """Create a new Persisted Query List."""
  createPersistedQueryList(description: String, name: String!): CreatePersistedQueryListResultOrError!

  """
  Provides access to mutation fields for modifying a Persisted Query List with the provided ID.
  """
  persistedQueryList(id: ID!): PersistedQueryListMutation!

  """
  Creates a proposal variant from a source variant and a name, description. See the documentation for proposal creation at https://www.apollographql.com/docs/graphos/delivery/schema-proposals/creation This field accepts up to 500 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  createProposal(input: CreateProposalInput!): CreateProposalResult!

  """
  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
    isProposalCheck: 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, downstreamLaunchInitiation: DownstreamLaunchInitiation = ASYNC): SubgraphPublicationResult

  """
  Publishes multiple subgraphs. If composition is successful, this will update running routers.
  This field accepts up to 120 requests per minute. This rate may be temporarily adjusted based on system conditions.
  """
  publishSubgraphs(graphVariant: String!, revision: String!, subgraphInputs: [PublishSubgraphsSubgraphInput!]!, gitContext: GitContextInput, downstreamLaunchInitiation: DownstreamLaunchInitiation = ASYNC): 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
    isProposalCheck: 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! @deprecated(reason: "Use GraphVariant.submitSubgraphCheckAsync instead.\nThis mutation polls to wait for the check to finish,\nwhile subgraphSubgraphCheckAsync triggers returns\nwithout waiting for the check to finish.")

  """Update schema check configuration for a graph."""
  updateCheckConfiguration(
    """Operations to ignore during validation."""
    excludedOperations: [ExcludedOperationInput!]

    """Clients to ignore during validation."""
    excludedClients: [ClientFilterInput!]

    """Operation names to ignore during validation."""
    excludedOperationNames: [OperationNameFilterInput!]

    """Variant overrides for validation."""
    includedVariants: [String!]

    """
    Only check operations from the last <timeRangeSeconds> seconds. The default is 7 days (604,800 seconds).
    """
    timeRangeSeconds: Long

    """
    Minimum number of requests within the window for a query to be considered.
    """
    operationCountThreshold: Int

    """
    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)
    """
    operationCountThresholdPercentage: Float

    """Default configuration to include operations on the base variant."""
    includeBaseVariant: Boolean

    """Whether to run Linting during schema checks."""
    enableLintChecks: Boolean

    """
    How submitted build input diffs are handled when they don't match a Proposal
    """
    proposalChangeMismatchSeverity: ProposalChangeMismatchSeverity @deprecated(reason: "Graph-level configuration is no longer supported")
    downgradeStaticChecks: Boolean
    downgradeDefaultValueChange: Boolean
    enableCustomChecks: Boolean
  ): CheckConfiguration!
}

"""
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 view details of the check configuration for this graph.
  """
  canQueryCheckConfiguration: Boolean!

  """
  Whether the currently authenticated user is permitted to make updates to the check configuration for this graph.
  """
  canWriteCheckConfiguration: Boolean!
  service: Graph!

  """
  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 delete proposal variants.
  """
  canDeleteProposalVariants: 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 manage proposal permission settings for this graph.
  """
  canManageProposalPermissions: Boolean!

  """
  Whether the currently authenticated user is permitted to manage proposal settings, like setting the implementation variant, on this graph.
  """
  canManageProposalSettings: 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 which subgraphs the graph is composed of.
  """
  canQueryImplementingServices: Boolean!
  canQueryProposals: 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!
  canCreateProposal: Boolean!

  """
  Given the graph's setting regarding proposal permission levels, can the current user edit Proposals authored by other users
  """
  canEditProposal: Boolean!
}

input SetCustomCheckConfigurationInput {
  secretToken: String
  url: String!
}

"""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!
}

"""Possible status of a Cloud Router version"""
enum Status {
  """Cloud Router Version is ready to be used by end users"""
  STABLE

  """
  Upcoming or experimental version of a Cloud Router
  
  This should only be used internally, or to preview new features to
  customers.
  """
  NEXT

  """
  Deprecated version of a Cloud Router
  
  New Cloud Routers should not use this version, and this will not be
  supported at some point in the future.
  """
  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 revision string of this publish if provided"""
  revision: String

  """
  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 automatically by a Proposal update."""
  isProposal: Boolean

  """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!
}

input SubgraphInput {
  """We are either going to pass in a document or a schema reference"""
  document: String
  name: String!
  routingURL: String!

  """
  Reference to a schema in studio.
  If this is a mutable ref i.e. graphRef then it will link (tbd)
  If it is a stable ref i.e. hash then it
  """
  schemaRef: String
}

input SubgraphSdlCheckInput {
  name: String!
  sdl: GraphQLDocument!
}

type TaskError {
  message: String!
}

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

type TopOperationRecord {
  """The graph this operation was reported from."""
  graphId: String!

  """The graph variant this operation was reported from."""
  graphVariant: String!

  """The operation name or null if the operation is unnamed."""
  name: String

  """The unique id for this operation."""
  operationId: String!

  """
  The total number of requests for this operation for the specified time range.
  """
  requestCount: Long!

  """
  The operation's signature body or null if the signature is unavailable due to parse errors.
  """
  signature: String

  """
  The operation type or null if the operation type could not be determined from the signature.
  """
  type: OperationType
}

enum TopOperationsReportOrderByColumn {
  REQUEST_COUNT
}

input TopOperationsReportOrderByInput {
  """
  The order column used for the operation results. Defaults to ordering by total request count.
  """
  column: TopOperationsReportOrderByColumn!

  """
  The direction used to order operation results. Defaults to descending order.
  """
  direction: Ordering!
}

input TopOperationsReportVariantFilterInInput {
  clientName: [String]
  clientVersion: [String]
}

input TopOperationsReportVariantFilterInput {
  in: TopOperationsReportVariantFilterInInput!
}

"""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!
}

"""
The result/error union returned by GraphVariantMutation.unlinkPersistedQueryList.
"""
union UnlinkPersistedQueryListResultOrError = PermissionError | VariantAlreadyUnlinkedError

"""Input to update a proposal description"""
input UpdateDescriptionInput {
  """A proposal description"""
  description: String!
}

union UpdateOperationCollectionEntryResult = OperationCollectionEntry | PermissionError | ValidationError

union UpdateOperationCollectionResult = OperationCollection | PermissionError | ValidationError

"""
The result of a successful call to PersistedQueryListMutation.updateMetadata.
"""
type UpdatePersistedQueryListMetadataResult {
  persistedQueryList: PersistedQueryList!
}

"""
The result/error union returned by PersistedQueryListMutation.updateMetadata.
"""
union UpdatePersistedQueryListMetadataResultOrError = PermissionError | UpdatePersistedQueryListMetadataResult

union UpdateProposalResult = PermissionError | Proposal | ValidationError

input UpdateRequestedReviewersInput {
  reviewerUserIdsToAdd: [ID!]
  reviewerUserIdsToRemove: [ID!]
}

union UpdateRequestedReviewersResult = PermissionError | Proposal | 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
}

union UpsertRouterResult = GraphVariant | RouterUpsertFailure

"""A registered Apollo Studio user."""
type User implements Identity {
  """
  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!

  """The user's first and last name."""
  name: String!

  """Returns a list of all active user API keys for the user."""
  apiKeys(includeCookies: Boolean = false): [UserApiKey!]!

  """A list of the user's memberships in Apollo Studio organizations."""
  memberships: [UserMembership!]!
}

"""
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! @deprecated(reason: "Use role instead.")

  """The user's role within the organization'."""
  role: UserPermission!

  """The user that belongs to the organization."""
  user: User!
}

type UserMutation {
  """
  Hard deletes the associated user. Throws an error otherwise with reason included.
  """
  hardDelete: Void

  """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
  PERSISTED_QUERY_PUBLISHER
}

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

"""
The result of a failed call to GraphVariantMutation.linkPersistedQueryList when the specified list is already linked.
"""
type VariantAlreadyLinkedError implements Error {
  message: String!
}

"""
The result of a failed call to GraphVariantMutation.unlinkPersistedQueryList when the specified list isn't linked.
"""
type VariantAlreadyUnlinkedError implements Error {
  message: String!
}

"""Variant-level configuration of checks."""
type VariantCheckConfiguration {
  customChecksConfig: VariantCheckConfigurationCustomChecks!

  """ID of the check configuration"""
  id: ID!

  """Time when the check configuration was created."""
  createdAt: Timestamp!

  """
  Operation checks configuration that allows associated checks to be downgraded from failure to passing.
  """
  downgradeChecksConfig: VariantCheckConfigurationDowngradeChecks!

  """
  Downstream checks configuration for which downstream variants should affect this variant's check
  status.
  """
  downstreamVariantsConfig: VariantCheckConfigurationDownstreamVariants!

  """Operation checks configuration for which clients to ignore."""
  excludedClientsConfig: VariantCheckConfigurationExcludedClients!

  """Operation checks configuration for which operation to ignore."""
  excludedOperationsConfig: VariantCheckConfigurationExcludedOperations!

  """Graph that this check configuration belongs to"""
  graphID: String!

  """Graph variant that this check configuration belongs to"""
  graphVariant: String!

  """
  Operation checks configuration for which variants' metrics data to include.
  """
  includedVariantsConfig: VariantCheckConfigurationIncludedVariants!

  """Whether operations checks are enabled."""
  operationsChecksEnabled: Boolean!

  """
  How submitted build input diffs are handled when they match (or don't) a Proposal at the variant level
  """
  proposalChangeMismatchSeverityConfig: VariantCheckConfigurationProposalChangeMismatchSeverity!

  """
  Operation checks configuration for time range and associated thresholds.
  """
  timeRangeConfig: VariantCheckConfigurationTimeRange!

  """Time when the check configuration was updated."""
  updatedAt: Timestamp!

  """
  Identity of the last actor to update the check configuration, if available.
  """
  updatedBy: Identity
}

type VariantCheckConfigurationCustomChecks {
  """
  When true, indicates that graph-level configuration is used for this variant setting. The default at variant creation is true.
  """
  useGraphSettings: Boolean!

  """
  Whether custom checks is enabled for this variant. Non-null if useGraphSettings is false, otherwise null.
  """
  enableCustomChecks: Boolean
}

type VariantCheckConfigurationDowngradeChecks {
  """
   During operation checks, if this option is enabled, the check will not fail or mark any operations as
  broken/changed if the default value has changed, only if the default value is removed completely.
  """
  downgradeDefaultValueChange: Boolean

  """
   During operation checks, if this option is enabled, it evaluates a check run against zero operations
  as a pass instead of a failure.
  """
  downgradeStaticChecks: Boolean

  """
  When true, indicates that graph-level configuration is used for this variant setting. The default
  at variant creation is true.
  """
  useGraphSettings: Boolean!
}

type VariantCheckConfigurationDownstreamVariants {
  """
  During downstream checks, this variant's check workflow will wait for all downstream check
  workflows for <blockingDownstreamVariants> variants to complete, and if any of them fail, then
  this variant's check workflow will fail.
  """
  blockingDownstreamVariants: [String!]!
}

type VariantCheckConfigurationExcludedClients {
  """
  When true, indicates that graph-level configuration is appended to the variant-level
  configuration. The default at variant creation is true.
  """
  appendGraphSettings: Boolean!

  """
  During operation checks, ignore clients matching any of the <excludedClients> filters. The
  default at variant creation is the empty list.
  """
  excludedClients: [ClientFilter!]!
}

type VariantCheckConfigurationExcludedOperations {
  """
  When true, indicates that graph-level configuration is appended to the variant-level
  configuration. The default at variant creation is true.
  """
  appendGraphSettings: Boolean!

  """
  During operation checks, ignore operations matching any of the <excludedOperationNames> filters.
  The default at variant creation is the empty list.
  """
  excludedOperationNames: [OperationNameFilter!]!

  """
  During operation checks, ignore operations matching any of the <excludedOperations> filters. The
  default at variant creation is the empty list.
  """
  excludedOperations: [OperationInfoFilter!]!
}

type VariantCheckConfigurationIncludedVariants {
  """
  During operation checks, fetch operations from the metrics data for <includedVariants> variants.
  Non-null if useGraphSettings is false and is otherwise null.
  """
  includedVariants: [String!]

  """
  When true, indicates that graph-level configuration is used for this variant setting. The default
  at variant creation is true.
  """
  useGraphSettings: Boolean!
}

type VariantCheckConfigurationProposalChangeMismatchSeverity {
  """
  How submitted build input diffs are handled when they match (or don't) a Proposal. Non-null if useGraphSettings is false and is otherwise null.
  """
  proposalChangeMismatchSeverity: ProposalChangeMismatchSeverity

  """
  When true, indicates that graph-level configuration is used for this variant setting. The default at variant creation is true.
  """
  useGraphSettings: Boolean!
}

type VariantCheckConfigurationTimeRange {
  """
  During operation checks, ignore operations that executed less than <operationCountThreshold>
  times in the time range. Non-null if useGraphSettings is false and is otherwise null.
  """
  operationCountThreshold: Int

  """
  Duration operation checks, ignore operations that constituted less than
  <operationCountThresholdPercentage>% of the operations in the time range. Expected values are
  between 0% and 5%. Non-null if useGraphSettings is false and is otherwise null.
  """
  operationCountThresholdPercentage: Float

  """
  During operation checks, fetch operations from the last <timeRangeSeconds> seconds. Non-null if
  useGraphSettings is false and is otherwise null.
  """
  timeRangeSeconds: Long

  """
  When true, indicates that graph-level configuration is used for this variant setting. The default
  at variant creation is true.
  """
  useGraphSettings: Boolean!
}

input VariantCreationConfig {
  buildConfigInput: BuildConfigInput!
  endpointSlug: String
  variantName: String!
}

enum ViolationLevel {
  ERROR
  INFO
  WARNING
}

"""Always null"""
scalar Void
