@graphql-hive/cli
Version:
A CLI util to manage and control your GraphQL Hive
1,350 lines • 171 kB
TypeScript
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
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;
};
JSON: {
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']>;
first?: InputMaybe<Scalars['Int']['input']>;
};
export type AppDeploymentConnection = {
__typename?: 'AppDeploymentConnection';
edges: Array<AppDeploymentEdge>;
pageInfo: PageInfo;
};
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']>;
};
export type DeprecatedSchemaExplorer = {
__typename?: 'DeprecatedSchemaExplorer';
types: Array<GraphQlNamedType>;
};
export type DeprecatedSchemaExplorerUsageInput = {
period: DateRangeInput;
};
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 DisableExternalSchemaCompositionInput = {
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
};
/** @oneOf */
export type DisableExternalSchemaCompositionResult = {
__typename?: 'DisableExternalSchemaCompositionResult';
error?: Maybe<Scalars['String']['output']>;
ok?: Maybe<Project>;
};
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 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 EnableExternalSchemaCompositionError = Error & {
__typename?: 'EnableExternalSchemaCompositionError';
/** The detailed validation error messages for the input fields. */
inputErrors: EnableExternalSchemaCompositionInputErrors;
message: Scalars['String']['output'];
};
export type EnableExternalSchemaCompositionInput = {
endpoint: Scalars['String']['input'];
organizationSlug: Scalars['String']['input'];
projectSlug: Scalars['String']['input'];
secret: Scalars['String']['input'];
};
export type EnableExternalSchemaCompositionInputErrors = {
__typename?: 'EnableExternalSchemaCompositionInputErrors';
endpoint?: Maybe<Scalars['String']['output']>;
secret?: Maybe<Scalars['String']['output']>;
};
/** @oneOf */
export type EnableExternalSchemaCompositionResult = {
__typename?: 'EnableExternalSchemaCompositionResult';
error?: Maybe<EnableExternalSchemaCompositionError>;
ok?: Maybe<Project>;
};
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 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'];