@graphql-hive/cli
Version:
A CLI util to manage and control your GraphQL Hive
1,340 lines • 184 kB
TypeScript
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = T | null | undefined;
export type Exact<T extends {
[key: string]: unknown;
}> = {
[K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
[SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
[SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
[key: string]: unknown;
}, K extends keyof T> = {
[_ in K]?: never;
};
export type Incremental<T> = T | {
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
ID: {
input: string;
output: string;
};
String: {
input: string;
output: string;
};
Boolean: {
input: boolean;
output: boolean;
};
Int: {
input: number;
output: number;
};
Float: {
input: number;
output: number;
};
Date: {
input: any;
output: any;
};
/**
* A date-time string at UTC, such as '2007-12-03T10:15:30Z', is compliant with the date-time format outlined
* in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.
*
* This scalar is a description of an exact instant on the timeline such as the instant that a user account was created.
*
* This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
*
* Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20+01:00' is shifted to '2016-01-01T13:10:20Z'.
*/
DateTime: {
input: any;
output: any;
};
/**
* A date-time string at UTC with nano-second precision, such as '2007-12-03T10:15:30.123456Z', is compliant with the extended date-time format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. The fractional part of the seconds can range up to nanosecond precision.
*
* This scalar represents an exact instant on the timeline, such as the precise moment a user account was created, including fractional seconds.
*
* This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
*
* Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20.500+01:00' is shifted to '2016-01-01T13:10:20.500Z'.
*/
DateTime64: {
input: any;
output: any;
};
JSON: {
input: any;
output: any;
};
JSONObject: {
input: any;
output: any;
};
JSONSchemaObject: {
input: any;
output: any;
};
SafeInt: {
input: any;
output: any;
};
};
export type ActivateAppDeploymentError = Error & {
__typename?: 'ActivateAppDeploymentError';
message: Scalars['String']['output'];
};
export type ActivateAppDeploymentInput = {
appName: Scalars['String']['input'];
appVersion: Scalars['String']['input'];
target?: InputMaybe<TargetReferenceInput>;
};
export type ActivateAppDeploymentOk = {
__typename?: 'ActivateAppDeploymentOk';
activatedAppDeployment: AppDeployment;
/** Whether the app deployment activation was skipped because it is already activated. */
isSkipped: Scalars['Boolean']['output'];
};
export type ActivateAppDeploymentResult = {
__typename?: 'ActivateAppDeploymentResult';
error?: Maybe<ActivateAppDeploymentError>;
ok?: Maybe<ActivateAppDeploymentOk>;
};
export type AddAlertChannelError = Error & {
__typename?: 'AddAlertChannelError';
inputErrors: AddAlertChannelInputErrors;
message: Scalars['String']['output'];
};
export type AddAlertChannelInput = {
name: Scalars['String']['input'];
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
slack?: InputMaybe<SlackChannelInput>;
type: AlertChannelType;
webhook?: InputMaybe<WebhookChannelInput>;
};
export type AddAlertChannelInputErrors = {
__typename?: 'AddAlertChannelInputErrors';
name?: Maybe<Scalars['String']['output']>;
slackChannel?: Maybe<Scalars['String']['output']>;
webhookEndpoint?: Maybe<Scalars['String']['output']>;
};
export type AddAlertChannelOk = {
__typename?: 'AddAlertChannelOk';
addedAlertChannel: AlertChannel;
updatedProject: Project;
};
export type AddAlertChannelResult = {
__typename?: 'AddAlertChannelResult';
error?: Maybe<AddAlertChannelError>;
ok?: Maybe<AddAlertChannelOk>;
};
export type AddAlertError = Error & {
__typename?: 'AddAlertError';
message: Scalars['String']['output'];
};
export type AddAlertInput = {
channelId: Scalars['ID']['input'];
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
targetSlug: Scalars['String']['input'];
type: AlertType;
};
export type AddAlertOk = {
__typename?: 'AddAlertOk';
addedAlert: Alert;
updatedProject: Project;
};
export type AddAlertResult = {
__typename?: 'AddAlertResult';
error?: Maybe<AddAlertError>;
ok?: Maybe<AddAlertOk>;
};
export type AddDocumentsToAppDeploymentError = Error & {
__typename?: 'AddDocumentsToAppDeploymentError';
/** Optional details if the error is related to a specific document. */
details?: Maybe<AddDocumentsToAppDeploymentErrorDetails>;
message: Scalars['String']['output'];
};
export type AddDocumentsToAppDeploymentErrorDetails = {
__typename?: 'AddDocumentsToAppDeploymentErrorDetails';
/** Index of the document sent from the client. */
index: Scalars['Int']['output'];
/** Error message for the document at the given index. */
message: Scalars['String']['output'];
};
export type AddDocumentsToAppDeploymentInput = {
/** Name of the app. */
appName: Scalars['String']['input'];
/** The version of the app */
appVersion: Scalars['String']['input'];
/** A list of operations to add to the app deployment. (max 100 per single batch) */
documents: Array<DocumentInput>;
target?: InputMaybe<TargetReferenceInput>;
};
export type AddDocumentsToAppDeploymentOk = {
__typename?: 'AddDocumentsToAppDeploymentOk';
appDeployment: AppDeployment;
};
export type AddDocumentsToAppDeploymentResult = {
__typename?: 'AddDocumentsToAppDeploymentResult';
error?: Maybe<AddDocumentsToAppDeploymentError>;
ok?: Maybe<AddDocumentsToAppDeploymentOk>;
};
export type AddGitHubIntegrationInput = {
installationId: Scalars['ID']['input'];
organizationSlug: Scalars['String']['input'];
};
export type AddSlackIntegrationInput = {
organizationSlug: Scalars['String']['input'];
token: Scalars['String']['input'];
};
export type AdminGeneralStats = {
__typename?: 'AdminGeneralStats';
operationsOverTime: Array<AdminOperationPoint>;
};
export type AdminOperationPoint = {
__typename?: 'AdminOperationPoint';
count: Scalars['SafeInt']['output'];
date: Scalars['DateTime']['output'];
};
export type AdminOrganizationStats = {
__typename?: 'AdminOrganizationStats';
operations: Scalars['SafeInt']['output'];
organization: Organization;
persistedOperations: Scalars['Int']['output'];
projects: Scalars['Int']['output'];
targets: Scalars['Int']['output'];
users: Scalars['Int']['output'];
versions: Scalars['Int']['output'];
};
export type AdminQuery = {
__typename?: 'AdminQuery';
stats: AdminStats;
};
export type AdminQueryStatsArgs = {
period: DateRangeInput;
resolution: Scalars['Int']['input'];
};
export type AdminStats = {
__typename?: 'AdminStats';
general: AdminGeneralStats;
organizations: Array<AdminOrganizationStats>;
};
export type Alert = {
__typename?: 'Alert';
channel: AlertChannel;
id: Scalars['ID']['output'];
target: Target;
type: AlertType;
};
export type AlertChannel = {
id: Scalars['ID']['output'];
name: Scalars['String']['output'];
type: AlertChannelType;
};
export declare enum AlertChannelType {
MsteamsWebhook = "MSTEAMS_WEBHOOK",
Slack = "SLACK",
Webhook = "WEBHOOK"
}
export type AlertSlackChannel = AlertChannel & {
__typename?: 'AlertSlackChannel';
channel: Scalars['String']['output'];
id: Scalars['ID']['output'];
name: Scalars['String']['output'];
type: AlertChannelType;
};
export declare enum AlertType {
SchemaChangeNotifications = "SCHEMA_CHANGE_NOTIFICATIONS"
}
export type AlertWebhookChannel = AlertChannel & {
__typename?: 'AlertWebhookChannel';
endpoint: Scalars['String']['output'];
id: Scalars['ID']['output'];
name: Scalars['String']['output'];
type: AlertChannelType;
};
export type AnswerOrganizationTransferRequestError = Error & {
__typename?: 'AnswerOrganizationTransferRequestError';
message: Scalars['String']['output'];
};
export type AnswerOrganizationTransferRequestInput = {
accept: Scalars['Boolean']['input'];
code: Scalars['String']['input'];
organizationSlug: Scalars['String']['input'];
};
export type AnswerOrganizationTransferRequestOk = {
__typename?: 'AnswerOrganizationTransferRequestOk';
accepted: Scalars['Boolean']['output'];
};
/** @oneOf */
export type AnswerOrganizationTransferRequestResult = {
__typename?: 'AnswerOrganizationTransferRequestResult';
error?: Maybe<AnswerOrganizationTransferRequestError>;
ok?: Maybe<AnswerOrganizationTransferRequestOk>;
};
export type AppDeployment = {
__typename?: 'AppDeployment';
documents?: Maybe<GraphQlDocumentConnection>;
id: Scalars['ID']['output'];
/** The last time a GraphQL request that used the app deployment was reported. */
lastUsed?: Maybe<Scalars['DateTime']['output']>;
name: Scalars['String']['output'];
status: AppDeploymentStatus;
totalDocumentCount: Scalars['Int']['output'];
version: Scalars['String']['output'];
};
export type AppDeploymentDocumentsArgs = {
after?: InputMaybe<Scalars['String']['input']>;
filter?: InputMaybe<AppDeploymentDocumentsFilterInput>;
first?: InputMaybe<Scalars['Int']['input']>;
};
export type AppDeploymentConnection = {
__typename?: 'AppDeploymentConnection';
edges: Array<AppDeploymentEdge>;
pageInfo: PageInfo;
};
export type AppDeploymentDocumentsFilterInput = {
operationName?: InputMaybe<Scalars['String']['input']>;
};
export type AppDeploymentEdge = {
__typename?: 'AppDeploymentEdge';
cursor: Scalars['String']['output'];
node: AppDeployment;
};
export type AppDeploymentOperation = {
/** GraphQL operation body. */
body: Scalars['String']['input'];
/** GraphQL operation hash. */
hash: Scalars['String']['input'];
};
export type AppDeploymentResourceAssignmentInput = {
appDeployment: Scalars['String']['input'];
};
export declare enum AppDeploymentStatus {
Active = "active",
Pending = "pending",
Retired = "retired"
}
export type ApproveFailedSchemaCheckError = {
__typename?: 'ApproveFailedSchemaCheckError';
message: Scalars['String']['output'];
};
export type ApproveFailedSchemaCheckInput = {
/**
* Optional comment visible in the schema check.
* Give a reason why the schema check was approved.
*/
comment?: InputMaybe<Scalars['String']['input']>;
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
schemaCheckId: Scalars['ID']['input'];
targetSlug: Scalars['String']['input'];
};
export type ApproveFailedSchemaCheckOk = {
__typename?: 'ApproveFailedSchemaCheckOk';
schemaCheck: SchemaCheck;
};
export type ApproveFailedSchemaCheckResult = {
__typename?: 'ApproveFailedSchemaCheckResult';
error?: Maybe<ApproveFailedSchemaCheckError>;
ok?: Maybe<ApproveFailedSchemaCheckOk>;
};
export type AssignMemberRoleInput = {
member: MemberReferenceInput;
memberRole: MemberRoleReferenceInput;
organization: OrganizationReferenceInput;
resources: ResourceAssignmentInput;
};
/** @oneOf */
export type AssignMemberRoleResult = {
__typename?: 'AssignMemberRoleResult';
error?: Maybe<AssignMemberRoleResultError>;
ok?: Maybe<AssignMemberRoleResultOk>;
};
export type AssignMemberRoleResultError = {
__typename?: 'AssignMemberRoleResultError';
message: Scalars['String']['output'];
};
export type AssignMemberRoleResultOk = {
__typename?: 'AssignMemberRoleResultOk';
previousMemberRole?: Maybe<MemberRole>;
updatedMember: Member;
};
export type AuditLogFilter = {
endDate: Scalars['DateTime']['input'];
startDate: Scalars['DateTime']['input'];
};
export declare enum AuthProviderType {
Github = "GITHUB",
Google = "GOOGLE",
/** OpenID Connect */
Oidc = "OIDC",
/** Username-Password-Authentication */
UsernamePassword = "USERNAME_PASSWORD"
}
export type BillingConfiguration = {
__typename?: 'BillingConfiguration';
billingAddress?: Maybe<BillingDetails>;
canUpdateSubscription: Scalars['Boolean']['output'];
hasActiveSubscription: Scalars['Boolean']['output'];
hasPaymentIssues: Scalars['Boolean']['output'];
invoices?: Maybe<Array<BillingInvoice>>;
paymentMethod?: Maybe<BillingPaymentMethod>;
upcomingInvoice?: Maybe<BillingInvoice>;
};
export type BillingDetails = {
__typename?: 'BillingDetails';
city?: Maybe<Scalars['String']['output']>;
country?: Maybe<Scalars['String']['output']>;
line1?: Maybe<Scalars['String']['output']>;
line2?: Maybe<Scalars['String']['output']>;
postalCode?: Maybe<Scalars['String']['output']>;
state?: Maybe<Scalars['String']['output']>;
};
export type BillingInvoice = {
__typename?: 'BillingInvoice';
amount: Scalars['Float']['output'];
date: Scalars['DateTime']['output'];
id: Scalars['ID']['output'];
pdfLink?: Maybe<Scalars['String']['output']>;
periodEnd: Scalars['DateTime']['output'];
periodStart: Scalars['DateTime']['output'];
status: BillingInvoiceStatus;
};
export declare enum BillingInvoiceStatus {
Draft = "DRAFT",
Open = "OPEN",
Paid = "PAID",
Uncollectible = "UNCOLLECTIBLE",
Void = "VOID"
}
export type BillingPaymentMethod = {
__typename?: 'BillingPaymentMethod';
brand: Scalars['String']['output'];
expMonth: Scalars['Int']['output'];
expYear: Scalars['Int']['output'];
last4: Scalars['String']['output'];
};
export type BillingPlan = {
__typename?: 'BillingPlan';
basePrice?: Maybe<Scalars['Float']['output']>;
description?: Maybe<Scalars['String']['output']>;
id: Scalars['ID']['output'];
includedOperationsLimit?: Maybe<Scalars['SafeInt']['output']>;
name: Scalars['String']['output'];
planType: BillingPlanType;
pricePerOperationsUnit?: Maybe<Scalars['Float']['output']>;
rateLimit: UsageRateLimitType;
retentionInDays: Scalars['Int']['output'];
};
export declare enum BillingPlanType {
Enterprise = "ENTERPRISE",
Hobby = "HOBBY",
Pro = "PRO"
}
export declare enum BreakingChangeFormulaType {
Percentage = "PERCENTAGE",
RequestCount = "REQUEST_COUNT"
}
export type BreakingChangeMetadataTarget = {
__typename?: 'BreakingChangeMetadataTarget';
id: Scalars['ID']['output'];
slug: Scalars['String']['output'];
target?: Maybe<Target>;
};
export type CdnAccessToken = {
__typename?: 'CdnAccessToken';
alias: Scalars['String']['output'];
createdAt: Scalars['DateTime']['output'];
firstCharacters: Scalars['String']['output'];
id: Scalars['ID']['output'];
lastCharacters: Scalars['String']['output'];
};
/** @oneOf */
export type CdnAccessTokenCreateResult = {
__typename?: 'CdnAccessTokenCreateResult';
error?: Maybe<CdnAccessTokenCreateResultError>;
ok?: Maybe<CdnAccessTokenCreateResultOk>;
};
export type CdnAccessTokenCreateResultError = {
__typename?: 'CdnAccessTokenCreateResultError';
message: Scalars['String']['output'];
};
export type CdnAccessTokenCreateResultOk = {
__typename?: 'CdnAccessTokenCreateResultOk';
cdnUrl: Scalars['String']['output'];
createdCdnAccessToken: CdnAccessToken;
secretAccessToken: Scalars['String']['output'];
};
export type ChangePlanResult = {
__typename?: 'ChangePlanResult';
newPlan: BillingPlanType;
organization: Organization;
previousPlan: BillingPlanType;
};
export type ClientNameStatsValues = {
__typename?: 'ClientNameStatsValues';
count: Scalars['Float']['output'];
name: Scalars['String']['output'];
};
export type ClientStats = {
__typename?: 'ClientStats';
operations: OperationStatsValuesConnection;
requestsOverTime: Array<RequestsOverTime>;
totalRequests: Scalars['SafeInt']['output'];
totalVersions: Scalars['SafeInt']['output'];
versions: Array<ClientVersionStatsValues>;
};
export type ClientStatsRequestsOverTimeArgs = {
resolution: Scalars['Int']['input'];
};
export type ClientStatsVersionsArgs = {
limit: Scalars['Int']['input'];
};
export type ClientStatsByTargetsInput = {
organizationSlug: Scalars['String']['input'];
period: DateRangeInput;
projectSlug: Scalars['String']['input'];
targetIds: Array<Scalars['ID']['input']>;
};
export type ClientStatsValues = {
__typename?: 'ClientStatsValues';
count: Scalars['Float']['output'];
name: Scalars['String']['output'];
percentage: Scalars['Float']['output'];
versions: Array<ClientVersionStatsValues>;
};
export type ClientStatsValuesConnection = {
__typename?: 'ClientStatsValuesConnection';
edges: Array<ClientStatsValuesEdge>;
pageInfo: PageInfo;
};
export type ClientStatsValuesEdge = {
__typename?: 'ClientStatsValuesEdge';
cursor: Scalars['String']['output'];
node: ClientStatsValues;
};
export type ClientVersionStatsValues = {
__typename?: 'ClientVersionStatsValues';
count: Scalars['Float']['output'];
percentage: Scalars['Float']['output'];
version: Scalars['String']['output'];
};
export type CodePosition = {
__typename?: 'CodePosition';
column: Scalars['Int']['output'];
line: Scalars['Int']['output'];
};
export type CompositeSchema = {
__typename?: 'CompositeSchema';
author: Scalars['String']['output'];
commit: Scalars['ID']['output'];
date: Scalars['DateTime']['output'];
id: Scalars['ID']['output'];
metadata?: Maybe<Scalars['String']['output']>;
service?: Maybe<Scalars['String']['output']>;
source: Scalars['String']['output'];
url?: Maybe<Scalars['String']['output']>;
};
export type ConditionalBreakingChangeConfiguration = {
__typename?: 'ConditionalBreakingChangeConfiguration';
/**
* Determines which formula is used to determine if a change is considered breaking
* or not. Only one formula can be used at a time.
*/
breakingChangeFormula: BreakingChangeFormulaType;
/** List of client names that are be excluded from the breaking change detection. */
excludedClients: Array<Scalars['String']['output']>;
/** Whether conditional breaking change detection is enabled. */
isEnabled: Scalars['Boolean']['output'];
/**
* If TargetValidationSettings.breakingChangeFormula is PERCENTAGE, then this
* is the percent of the total operations over the TargetValidationSettings.period
* required for a change to be considered breaking.
*/
percentage: Scalars['Float']['output'];
/** The period in days. Operations of the last x days will be used for the conditional breaking change detection. */
period: Scalars['Int']['output'];
/**
* If TargetValidationSettings.breakingChangeFormula is REQUEST_COUNT, then this
* is the total number of operations over the TargetValidationSettings.period
* required for a change to be considered breaking.
*/
requestCount: Scalars['Int']['output'];
/** List of target within the same project, whose operations are used for the breaking change detection. */
targets: Array<Target>;
};
/** Fields not provided (omitted) will retain the previous value. */
export type ConditionalBreakingChangeConfigurationInput = {
/** Whether a percentage or absolute value should be used for the conditional breaking changes treshold. */
breakingChangeFormula?: InputMaybe<BreakingChangeFormulaType>;
/** List of client names that are excluded from the breaking change detection. */
excludedClients?: InputMaybe<Array<Scalars['String']['input']>>;
/** Update whethe the conditional breaking change detection is enabled or disabled. */
isEnabled?: InputMaybe<Scalars['Boolean']['input']>;
/** The percentage value if `UpdateTargetValidationSettingsInput.breakingChangeFormula` is set to `BreakingChangeFormulaType.PERCENTAGE`. */
percentage?: InputMaybe<Scalars['Float']['input']>;
/**
* The period in days. Operations of the last x days will be used for the conditional breaking change detection.
* The maximum value depends on the organizations data retention limits.
*/
period?: InputMaybe<Scalars['Int']['input']>;
/** The request count value if `UpdateTargetValidationSettingsInput.breakingChangeFormula` is set to `BreakingChangeFormulaType.REQUEST_COUNT`. */
requestCount?: InputMaybe<Scalars['Int']['input']>;
/** List of target ids within the same project, whose operations are used for the breaking change detection. */
targetIds?: InputMaybe<Array<Scalars['ID']['input']>>;
};
export type Contract = {
__typename?: 'Contract';
/** The URL for accessing this contracts's artifacts via the CDN. */
cdnUrl: Scalars['String']['output'];
contractName: Scalars['String']['output'];
createdAt: Scalars['DateTime']['output'];
excludeTags?: Maybe<Array<Scalars['String']['output']>>;
id: Scalars['ID']['output'];
includeTags?: Maybe<Array<Scalars['String']['output']>>;
isDisabled: Scalars['Boolean']['output'];
removeUnreachableTypesFromPublicApiSchema: Scalars['Boolean']['output'];
target: Target;
viewerCanDisableContract: Scalars['Boolean']['output'];
};
/** Schema check result for contracts */
export type ContractCheck = {
__typename?: 'ContractCheck';
breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
compositeSchemaSDL?: Maybe<Scalars['String']['output']>;
contractName: Scalars['String']['output'];
/** The contract version against this check was performed. */
contractVersion?: Maybe<ContractVersion>;
/** Whether this schema check has any schema changes. */
hasSchemaChanges: Scalars['Boolean']['output'];
/** Whether this schema check has any composition errors. */
hasSchemaCompositionErrors: Scalars['Boolean']['output'];
/** Whether this schema check has any breaking changes. */
hasUnapprovedBreakingChanges: Scalars['Boolean']['output'];
id: Scalars['ID']['output'];
isSuccess: Scalars['Boolean']['output'];
safeSchemaChanges?: Maybe<SchemaChangeConnection>;
schemaChanges?: Maybe<SchemaChangeConnection>;
schemaCompositionErrors?: Maybe<SchemaErrorConnection>;
supergraphSDL?: Maybe<Scalars['String']['output']>;
};
export type ContractCheckConnection = {
__typename?: 'ContractCheckConnection';
edges: Array<ContractCheckEdge>;
pageInfo: PageInfo;
};
export type ContractCheckEdge = {
__typename?: 'ContractCheckEdge';
cursor: Scalars['String']['output'];
node: ContractCheck;
};
export type ContractConnection = {
__typename?: 'ContractConnection';
edges: Array<ContractEdge>;
pageInfo: PageInfo;
};
export type ContractEdge = {
__typename?: 'ContractEdge';
cursor: Scalars['String']['output'];
node: Contract;
};
export type ContractReferenceInput = {
byId: Scalars['ID']['input'];
};
export type ContractVersion = {
__typename?: 'ContractVersion';
/** Breaking schema changes for this contract version. */
breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
compositeSchemaSDL?: Maybe<Scalars['String']['output']>;
contractName: Scalars['String']['output'];
createdAt: Scalars['String']['output'];
/** Whether this contract versions has schema changes. */
hasSchemaChanges: Scalars['Boolean']['output'];
id: Scalars['ID']['output'];
/** Whether this contract version is composable. */
isComposable: Scalars['Boolean']['output'];
isFirstComposableVersion: Scalars['Boolean']['output'];
previousContractVersion?: Maybe<ContractVersion>;
previousDiffableContractVersion?: Maybe<ContractVersion>;
/** Safe schema changes for this contract version. */
safeSchemaChanges?: Maybe<SchemaChangeConnection>;
schemaChanges?: Maybe<SchemaChangeConnection>;
schemaCompositionErrors?: Maybe<SchemaErrorConnection>;
supergraphSDL?: Maybe<Scalars['String']['output']>;
};
export type ContractVersionConnection = {
__typename?: 'ContractVersionConnection';
edges: Array<ContractVersionEdge>;
pageInfo: PageInfo;
};
export type ContractVersionEdge = {
__typename?: 'ContractVersionEdge';
cursor: Scalars['String']['output'];
node: ContractVersion;
};
export type CreateAppDeploymentError = Error & {
__typename?: 'CreateAppDeploymentError';
details?: Maybe<CreateAppDeploymentErrorDetails>;
message: Scalars['String']['output'];
};
export type CreateAppDeploymentErrorDetails = {
__typename?: 'CreateAppDeploymentErrorDetails';
/** Error message for the input app name. */
appName?: Maybe<Scalars['String']['output']>;
/** Error message for the input app version. */
appVersion?: Maybe<Scalars['String']['output']>;
};
export type CreateAppDeploymentInput = {
appName: Scalars['String']['input'];
appVersion: Scalars['String']['input'];
target?: InputMaybe<TargetReferenceInput>;
};
export type CreateAppDeploymentOk = {
__typename?: 'CreateAppDeploymentOk';
createdAppDeployment: AppDeployment;
};
export type CreateAppDeploymentResult = {
__typename?: 'CreateAppDeploymentResult';
error?: Maybe<CreateAppDeploymentError>;
ok?: Maybe<CreateAppDeploymentOk>;
};
export type CreateCdnAccessTokenInput = {
/** Alias describing the purpose of the access token. */
alias: Scalars['String']['input'];
/** The target for which the access token should be created for. */
target: TargetReferenceInput;
};
export type CreateContractInput = {
contractName: Scalars['String']['input'];
excludeTags?: InputMaybe<Array<Scalars['String']['input']>>;
includeTags?: InputMaybe<Array<Scalars['String']['input']>>;
removeUnreachableTypesFromPublicApiSchema: Scalars['Boolean']['input'];
target: TargetReferenceInput;
};
export type CreateContractInputErrors = {
__typename?: 'CreateContractInputErrors';
contractName?: Maybe<Scalars['String']['output']>;
excludeTags?: Maybe<Scalars['String']['output']>;
includeTags?: Maybe<Scalars['String']['output']>;
target?: Maybe<Scalars['String']['output']>;
};
export type CreateContractResult = {
__typename?: 'CreateContractResult';
error?: Maybe<CreateContractResultError>;
ok?: Maybe<CreateContractResultOk>;
};
export type CreateContractResultError = {
__typename?: 'CreateContractResultError';
details: CreateContractInputErrors;
message: Scalars['String']['output'];
};
export type CreateContractResultOk = {
__typename?: 'CreateContractResultOk';
createdContract: Contract;
};
export type CreateDocumentCollectionInput = {
description?: InputMaybe<Scalars['String']['input']>;
name: Scalars['String']['input'];
};
export type CreateDocumentCollectionOperationInput = {
collectionId: Scalars['ID']['input'];
headers?: InputMaybe<Scalars['String']['input']>;
name: Scalars['String']['input'];
query: Scalars['String']['input'];
variables?: InputMaybe<Scalars['String']['input']>;
};
export type CreateMemberRoleInput = {
/** A description describing the purpose of the member role. */
description: Scalars['String']['input'];
/** The name of the member role (must be unique). */
name: Scalars['String']['input'];
/** The organization in which the member role should be created. */
organization: OrganizationReferenceInput;
/** A list of available permissions can be retrieved via the 'Organization.availableMemberPermissionGroups' field. */
selectedPermissions: Array<Scalars['String']['input']>;
};
export type CreateMemberRoleInputErrors = {
__typename?: 'CreateMemberRoleInputErrors';
description?: Maybe<Scalars['String']['output']>;
name?: Maybe<Scalars['String']['output']>;
};
/** @oneOf */
export type CreateMemberRoleResult = {
__typename?: 'CreateMemberRoleResult';
error?: Maybe<CreateMemberRoleResultError>;
ok?: Maybe<CreateMemberRoleResultOk>;
};
export type CreateMemberRoleResultError = {
__typename?: 'CreateMemberRoleResultError';
/** The detailed validation error messages for the input fields. */
inputErrors?: Maybe<CreateMemberRoleInputErrors>;
message: Scalars['String']['output'];
};
export type CreateMemberRoleResultOk = {
__typename?: 'CreateMemberRoleResultOk';
createdMemberRole: MemberRole;
updatedOrganization: Organization;
};
export type CreateOidcIntegrationError = Error & {
__typename?: 'CreateOIDCIntegrationError';
details: CreateOidcIntegrationErrorDetails;
message: Scalars['String']['output'];
};
export type CreateOidcIntegrationErrorDetails = {
__typename?: 'CreateOIDCIntegrationErrorDetails';
authorizationEndpoint?: Maybe<Scalars['String']['output']>;
clientId?: Maybe<Scalars['String']['output']>;
clientSecret?: Maybe<Scalars['String']['output']>;
tokenEndpoint?: Maybe<Scalars['String']['output']>;
userinfoEndpoint?: Maybe<Scalars['String']['output']>;
};
export type CreateOidcIntegrationInput = {
authorizationEndpoint: Scalars['String']['input'];
clientId: Scalars['ID']['input'];
clientSecret: Scalars['String']['input'];
organizationId: Scalars['ID']['input'];
tokenEndpoint: Scalars['String']['input'];
userinfoEndpoint: Scalars['String']['input'];
};
export type CreateOidcIntegrationOk = {
__typename?: 'CreateOIDCIntegrationOk';
createdOIDCIntegration: OidcIntegration;
organization: Organization;
};
export type CreateOidcIntegrationResult = {
__typename?: 'CreateOIDCIntegrationResult';
error?: Maybe<CreateOidcIntegrationError>;
ok?: Maybe<CreateOidcIntegrationOk>;
};
export type CreateOrganizationAccessTokenInput = {
/** Additional description containing information about the purpose of the access token. */
description?: InputMaybe<Scalars['String']['input']>;
/** Organization in which the access token should be created. */
organization: OrganizationReferenceInput;
/**
* List of permissions that are assigned to the access token.
* A list of available permissions can be retrieved via the 'Organization.availableOrganizationAccessTokenPermissionGroups' field.
*/
permissions: Array<Scalars['String']['input']>;
/**
* Resources on which the permissions should be granted (project, target, service, and app deployments).
* Permissions are inherited by sub-resources.
*/
resources: ResourceAssignmentInput;
/** Title of the access token. */
title: Scalars['String']['input'];
};
export type CreateOrganizationAccessTokenResult = {
__typename?: 'CreateOrganizationAccessTokenResult';
error?: Maybe<CreateOrganizationAccessTokenResultError>;
ok?: Maybe<CreateOrganizationAccessTokenResultOk>;
};
export type CreateOrganizationAccessTokenResultError = {
__typename?: 'CreateOrganizationAccessTokenResultError';
details?: Maybe<CreateOrganizationAccessTokenResultErrorDetails>;
message: Scalars['String']['output'];
};
export type CreateOrganizationAccessTokenResultErrorDetails = {
__typename?: 'CreateOrganizationAccessTokenResultErrorDetails';
/** Error message for the input description. */
description?: Maybe<Scalars['String']['output']>;
/** Error message for the input title. */
title?: Maybe<Scalars['String']['output']>;
};
export type CreateOrganizationAccessTokenResultOk = {
__typename?: 'CreateOrganizationAccessTokenResultOk';
createdOrganizationAccessToken: OrganizationAccessToken;
privateAccessKey: Scalars['String']['output'];
};
export type CreateOrganizationError = Error & {
__typename?: 'CreateOrganizationError';
inputErrors: CreateOrganizationInputErrors;
message: Scalars['String']['output'];
};
export type CreateOrganizationInput = {
slug: Scalars['String']['input'];
};
export type CreateOrganizationInputErrors = {
__typename?: 'CreateOrganizationInputErrors';
slug?: Maybe<Scalars['String']['output']>;
};
export type CreateOrganizationOk = {
__typename?: 'CreateOrganizationOk';
createdOrganizationPayload: OrganizationPayload;
};
/** @oneOf */
export type CreateOrganizationResult = {
__typename?: 'CreateOrganizationResult';
error?: Maybe<CreateOrganizationError>;
ok?: Maybe<CreateOrganizationOk>;
};
export type CreateProjectInput = {
organization: OrganizationReferenceInput;
slug: Scalars['String']['input'];
type: ProjectType;
};
export type CreateProjectInputErrors = {
__typename?: 'CreateProjectInputErrors';
slug?: Maybe<Scalars['String']['output']>;
};
export type CreateProjectResult = {
__typename?: 'CreateProjectResult';
error?: Maybe<CreateProjectResultError>;
ok?: Maybe<CreateProjectResultOk>;
};
export type CreateProjectResultError = {
__typename?: 'CreateProjectResultError';
inputErrors: CreateProjectInputErrors;
message: Scalars['String']['output'];
};
export type CreateProjectResultOk = {
__typename?: 'CreateProjectResultOk';
createdProject: Project;
createdTargets: Array<Target>;
updatedOrganization: Organization;
};
export type CreateTargetInput = {
/** Reference to the project in which the target should be created in. */
project: ProjectReferenceInput;
/** Slug of the target, must be unique per project. */
slug: Scalars['String']['input'];
};
export type CreateTargetInputErrors = {
__typename?: 'CreateTargetInputErrors';
slug?: Maybe<Scalars['String']['output']>;
};
export type CreateTargetResult = {
__typename?: 'CreateTargetResult';
error?: Maybe<CreateTargetResultError>;
ok?: Maybe<CreateTargetResultOk>;
};
export type CreateTargetResultError = {
__typename?: 'CreateTargetResultError';
inputErrors: CreateTargetInputErrors;
message: Scalars['String']['output'];
};
export type CreateTargetResultOk = {
__typename?: 'CreateTargetResultOk';
createdTarget: Target;
selector: TargetSelector;
};
export type CreateTokenError = Error & {
__typename?: 'CreateTokenError';
message: Scalars['String']['output'];
};
export type CreateTokenInput = {
name: Scalars['String']['input'];
organizationScopes: Array<OrganizationAccessScope>;
organizationSlug: Scalars['String']['input'];
projectScopes: Array<ProjectAccessScope>;
projectSlug: Scalars['String']['input'];
targetScopes: Array<TargetAccessScope>;
targetSlug: Scalars['String']['input'];
};
export type CreateTokenOk = {
__typename?: 'CreateTokenOk';
createdToken: Token;
secret: Scalars['String']['output'];
selector: TargetSelector;
};
export type CreateTokenPayload = {
__typename?: 'CreateTokenPayload';
createdToken: Token;
secret: Scalars['String']['output'];
selector: TargetSelector;
};
export type CreateTokenResult = {
__typename?: 'CreateTokenResult';
error?: Maybe<CreateTokenError>;
ok?: Maybe<CreateTokenOk>;
};
export declare enum CriticalityLevel {
/** @deprecated Use 'SeverityLevelType' instead. This field will be removed once it is no longer in use by a client. */
Breaking = "Breaking",
/** @deprecated Use 'SeverityLevelType' instead. This field will be removed once it is no longer in use by a client. */
Dangerous = "Dangerous",
/** @deprecated Use 'SeverityLevelType' instead. This field will be removed once it is no longer in use by a client. */
Safe = "Safe"
}
export type DateRange = {
__typename?: 'DateRange';
from: Scalars['DateTime']['output'];
to: Scalars['DateTime']['output'];
};
/** Describes a date range interval. */
export type DateRangeInput = {
from: Scalars['DateTime']['input'];
to: Scalars['DateTime']['input'];
};
export type DeleteAlertChannelsError = Error & {
__typename?: 'DeleteAlertChannelsError';
message: Scalars['String']['output'];
};
export type DeleteAlertChannelsInput = {
channelIds: Array<Scalars['ID']['input']>;
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
};
export type DeleteAlertChannelsOk = {
__typename?: 'DeleteAlertChannelsOk';
updatedProject: Project;
};
export type DeleteAlertChannelsResult = {
__typename?: 'DeleteAlertChannelsResult';
error?: Maybe<DeleteAlertChannelsError>;
ok?: Maybe<DeleteAlertChannelsOk>;
};
export type DeleteAlertsError = Error & {
__typename?: 'DeleteAlertsError';
message: Scalars['String']['output'];
};
export type DeleteAlertsInput = {
alertIds: Array<Scalars['ID']['input']>;
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
};
export type DeleteAlertsOk = {
__typename?: 'DeleteAlertsOk';
updatedProject: Project;
};
export type DeleteAlertsResult = {
__typename?: 'DeleteAlertsResult';
error?: Maybe<DeleteAlertsError>;
ok?: Maybe<DeleteAlertsOk>;
};
export type DeleteCdnAccessTokenInput = {
cdnAccessTokenId: Scalars['ID']['input'];
target: TargetReferenceInput;
};
/** @oneOf */
export type DeleteCdnAccessTokenResult = {
__typename?: 'DeleteCdnAccessTokenResult';
error?: Maybe<DeleteCdnAccessTokenResultError>;
ok?: Maybe<DeleteCdnAccessTokenResultOk>;
};
export type DeleteCdnAccessTokenResultError = {
__typename?: 'DeleteCdnAccessTokenResultError';
message: Scalars['String']['output'];
};
export type DeleteCdnAccessTokenResultOk = {
__typename?: 'DeleteCdnAccessTokenResultOk';
deletedCdnAccessTokenId: Scalars['ID']['output'];
};
export type DeleteDocumentCollectionOkPayload = {
__typename?: 'DeleteDocumentCollectionOkPayload';
deletedId: Scalars['ID']['output'];
updatedTarget: Target;
};
export type DeleteDocumentCollectionOperationOkPayload = {
__typename?: 'DeleteDocumentCollectionOperationOkPayload';
deletedId: Scalars['ID']['output'];
updatedCollection: DocumentCollection;
updatedTarget: Target;
};
/** @oneOf */
export type DeleteDocumentCollectionOperationResult = {
__typename?: 'DeleteDocumentCollectionOperationResult';
error?: Maybe<ModifyDocumentCollectionError>;
ok?: Maybe<DeleteDocumentCollectionOperationOkPayload>;
};
/** @oneOf */
export type DeleteDocumentCollectionResult = {
__typename?: 'DeleteDocumentCollectionResult';
error?: Maybe<ModifyDocumentCollectionError>;
ok?: Maybe<DeleteDocumentCollectionOkPayload>;
};
export type DeleteGitHubIntegrationResult = {
__typename?: 'DeleteGitHubIntegrationResult';
organization: Organization;
};
export type DeleteMemberRoleInput = {
memberRole: MemberRoleReferenceInput;
};
/** @oneOf */
export type DeleteMemberRoleResult = {
__typename?: 'DeleteMemberRoleResult';
error?: Maybe<DeleteMemberRoleResultError>;
ok?: Maybe<DeleteMemberRoleResultOk>;
};
export type DeleteMemberRoleResultError = {
__typename?: 'DeleteMemberRoleResultError';
message: Scalars['String']['output'];
};
export type DeleteMemberRoleResultOk = {
__typename?: 'DeleteMemberRoleResultOk';
deletedMemberRoleId: Scalars['ID']['output'];
updatedOrganization: Organization;
};
export type DeleteOidcIntegrationError = Error & {
__typename?: 'DeleteOIDCIntegrationError';
message: Scalars['String']['output'];
};
export type DeleteOidcIntegrationInput = {
oidcIntegrationId: Scalars['ID']['input'];
};
export type DeleteOidcIntegrationOk = {
__typename?: 'DeleteOIDCIntegrationOk';
organization: Organization;
};
export type DeleteOidcIntegrationResult = {
__typename?: 'DeleteOIDCIntegrationResult';
error?: Maybe<DeleteOidcIntegrationError>;
ok?: Maybe<DeleteOidcIntegrationOk>;
};
export type DeleteOrganizationAccessTokenInput = {
/** The access token that should be deleted. */
organizationAccessToken: OrganizationAccessTokenReference;
};
export type DeleteOrganizationAccessTokenResult = {
__typename?: 'DeleteOrganizationAccessTokenResult';
error?: Maybe<DeleteOrganizationAccessTokenResultError>;
ok?: Maybe<DeleteOrganizationAccessTokenResultOk>;
};
export type DeleteOrganizationAccessTokenResultError = {
__typename?: 'DeleteOrganizationAccessTokenResultError';
message: Scalars['String']['output'];
};
export type DeleteOrganizationAccessTokenResultOk = {
__typename?: 'DeleteOrganizationAccessTokenResultOk';
deletedOrganizationAccessTokenId: Scalars['ID']['output'];
};
export type DeleteOrganizationInvitationInput = {
email: Scalars['String']['input'];
organization: OrganizationReferenceInput;
};
/** @oneOf */
export type DeleteOrganizationInvitationResult = {
__typename?: 'DeleteOrganizationInvitationResult';
error?: Maybe<DeleteOrganizationInvitationResultError>;
ok?: Maybe<DeleteOrganizationInvitationResultOk>;
};
export type DeleteOrganizationInvitationResultError = {
__typename?: 'DeleteOrganizationInvitationResultError';
message: Scalars['String']['output'];
};
export type DeleteOrganizationInvitationResultOk = {
__typename?: 'DeleteOrganizationInvitationResultOk';
deletedOrganizationInvitationId: Scalars['ID']['output'];
};
export type DeleteProjectInput = {
project: ProjectReferenceInput;
};
export type DeleteProjectResult = {
__typename?: 'DeleteProjectResult';
error?: Maybe<DeleteProjectResultError>;
ok?: Maybe<DeleteProjectResultOk>;
};
export type DeleteProjectResultError = {
__typename?: 'DeleteProjectResultError';
message: Scalars['String']['output'];
};
export type DeleteProjectResultOk = {
__typename?: 'DeleteProjectResultOk';
deletedProjectId: Scalars['ID']['output'];
};
export type DeleteSlackIntegrationResult = {
__typename?: 'DeleteSlackIntegrationResult';
organization: Organization;
};
export type DeleteTargetInput = {
/** Reference to the target that should be deleted. */
target: TargetReferenceInput;
};
export type DeleteTargetPayload = {
__typename?: 'DeleteTargetPayload';
deletedTarget: Target;
selector: TargetSelector;
};
export type DeleteTargetResult = {
__typename?: 'DeleteTargetResult';
error?: Maybe<DeleteTargetResultError>;
ok?: Maybe<DeleteTargetResultOk>;
};
export type DeleteTargetResultError = {
__typename?: 'DeleteTargetResultError';
message: Scalars['String']['output'];
};
export type DeleteTargetResultOk = {
__typename?: 'DeleteTargetResultOk';
deletedTargetId: Scalars['ID']['output'];
};
export type DeleteTokensInput = {
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
targetSlug: Scalars['String']['input'];
tokenIds: Array<Scalars['ID']['input']>;
};
export type DeleteTokensPayload = {
__typename?: 'DeleteTokensPayload';
deletedTokens: Array<Scalars['ID']['output']>;
selector: TargetSelector;
};
export type DeletedSchemaLog = {
__typename?: 'DeletedSchemaLog';
date: Scalars['DateTime']['output'];
/** The name of the service that got deleted. */
deletedService: Scalars['String']['output'];
id: Scalars['ID']['output'];
/** The previous SDL of the full schema or subgraph. */
previousServiceSdl?: Maybe<Scalars['String']['output']>;
};
/** Explorer for navigating the deprecated schema parts with usage data provided by the contextual period. */
export type DeprecatedSchemaExplorer = {
__typename?: 'DeprecatedSchemaExplorer';
/**
* The affected types whose fields/values/members are deprecated.
*
* The types within the result only contain deprecated fields/values/members, all other entities are excluded,
* they are not a representation of the full GraphQL schema.
*/
types: Array<GraphQlNamedType>;
};
export type DisableContractInput = {
contract: ContractReferenceInput;
};
export type DisableContractResult = {
__typename?: 'DisableContractResult';
error?: Maybe<DisableContractResultError>;
ok?: Maybe<DisableContractResultOk>;
};
export type DisableContractResultError = {
__typename?: 'DisableContractResultError';
message: Scalars['String']['output'];
};
export type DisableContractResultOk = {
__typename?: 'DisableContractResultOk';
disabledContract: Contract;
};
export type DocumentCollection = {
__typename?: 'DocumentCollection';
createdAt: Scalars['DateTime']['output'];
description?: Maybe<Scalars['String']['output']>;
id: Scalars['ID']['output'];
name: Scalars['String']['output'];
operations: DocumentCollectionOperationsConnection;
updatedAt: Scalars['DateTime']['output'];
};
export type DocumentCollectionOperationsArgs = {
after?: InputMaybe<Scalars['String']['input']>;
first?: InputMaybe<Scalars['Int']['input']>;
};
export type DocumentCollectionConnection = {
__typename?: 'DocumentCollectionConnection';
edges: Array<DocumentCollectionEdge>;
pageInfo: PageInfo;
};
export type DocumentCollectionEdge = {
__typename?: 'DocumentCollectionEdge';
cursor: Scalars['String']['output'];
node: DocumentCollection;
};
export type DocumentCollectionOperation = {
__typename?: 'DocumentCollectionOperation';
collection: DocumentCollection;
createdAt: Scalars['DateTime']['output'];
headers?: Maybe<Scalars['String']['output']>;
id: Scalars['ID']['output'];
name: Scalars['String']['output'];
query: Scalars['String']['output'];
updatedAt: Scalars['DateTime']['output'];
variables?: Maybe<Scalars['String']['output']>;
};
export type DocumentCollectionOperationEdge = {
__typename?: 'DocumentCollectionOperationEdge';
cursor: Scalars['String']['output'];
node: DocumentCollectionOperation;
};
export type DocumentCollectionOperationsConnection = {
__typename?: 'DocumentCollectionOperationsConnection';
edges: Array<DocumentCollectionOperationEdge>;
pageInfo: PageInfo;
};
export type DocumentInput = {
/** GraphQL operation body. */
body: Scalars['String']['input'];
/** GraphQL operation hash. */
hash: Scalars['String']['input'];
};
export type DowngradeToHobbyInput = {
organization: OrganizationSelectorInput;
};
export type DurationInput = {
max?: InputMaybe<Scalars['SafeInt']['input']>;
min?: InputMaybe<Scalars['SafeInt']['input']>;
};
export type DurationOverTime = {
__typename?: 'DurationOverTime';
date: Scalars['DateTime']['output'];
duration: DurationValues;
};
export type DurationValues = {
__typename?: 'DurationValues';
avg: Scalars['Int']['output'];
p75: Scalars['Int']['output'];
p90: Scalars['Int']['output'];
p95: Scalars['Int']['output'];
p99: Scalars['Int']['output'];
};
export type Error = {
message: Scalars['String']['output'];
};
export type Experimental__UpdateTargetSchemaCompositionInput = {
nativeComposition: Scalars['Boolean']['input'];
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
targetSlug: Scalars['String']['input'];
};
export type ExportOrganizationAuditLogError = Error & {
__typename?: 'ExportOrganizationAuditLogError';
message: Scalars['String']['output'];
};
export type ExportOrganizationAuditLogInput = {
filter: AuditLogFilter;
selector: OrganizationSelectorInput;
};
export type ExportOrganizationAuditLogPayload = {
__typename?: 'ExportOrganizationAuditLogPayload';
url: Scalars['String']['output'];
};
export type ExportOrganizationAuditLogResult = {
__typename?: 'ExportOrganizationAuditLogResult';
error?: Maybe<ExportOrganizationAuditLogError>;
ok?: Maybe<ExportOrganizationAuditLogPayload>;
};
export type ExternalSchemaComposition = {
__typename?: 'ExternalSchemaComposition';
endpoint: Scalars['String']['output'];
};
/** A failed schema check. */
export type FailedSchemaCheck = SchemaCheck & {
__typename?: 'FailedSchemaCheck';
breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
/** Whether this schema check can be approved manually. */
canBeApproved: Scalars['Boolean']['output'];
/** Whether this schema check can be approved by the viewer. */
canBeApprovedByViewer: Scalars['Boolean']['output'];
compositeSchemaSDL?: Maybe<Scalars['String']['output']>;
compositionErrors?: Maybe<SchemaErrorConnection>;
/** Conditional breaking change metadata. */
conditionalBreakingChangeMetadata?: Maybe<SchemaCheckConditionalBreakingChangeMetadata>;
/** Optional context ID to group schema checks together. */
contextId?: Maybe<Scalars['String']['output']>;
/** Results of the contracts */
contractChecks?: Maybe<ContractCheckConnection>;
createdAt: Scalars['String']['output'];
/** The GitHub repository associated with the schema check. */
githubRepository?: Maybe<Scalars['String']['output']>;
/** Whether this schema check has any schema cha