@graphql-hive/cli/dist/gql/graphql.d.ts

A CLI util to manage and control your GraphQL Hive

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;
    };
    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 AssignMemberRoleError = Error & {
    __typename?: 'AssignMemberRoleError';
    message: Scalars['String']['output'];
};
export type AssignMemberRoleInput = {
    organizationSlug: Scalars['String']['input'];
    resources: ResourceAssignmentInput;
    roleId: Scalars['ID']['input'];
    userId: Scalars['ID']['input'];
};
export type AssignMemberRoleOk = {
    __typename?: 'AssignMemberRoleOk';
    previousMemberRole?: Maybe<MemberRole>;
    updatedMember: Member;
};
/** @oneOf */
export type AssignMemberRoleResult = {
    __typename?: 'AssignMemberRoleResult';
    error?: Maybe<AssignMemberRoleError>;
    ok?: Maybe<AssignMemberRoleOk>;
};
export type AuditLogFilter = {
    endDate: Scalars['DateTime']['input'];
    startDate: Scalars['DateTime']['input'];
};
export declare enum AuthProvider {
    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 BreakingChangeFormula {
    Percentage = "PERCENTAGE",
    RequestCount = "REQUEST_COUNT"
}
export type BreakingChangeMetadataTarget = {
    __typename?: 'BreakingChangeMetadataTarget';
    name: 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'];
};
export type CdnAccessTokenCreateError = Error & {
    __typename?: 'CdnAccessTokenCreateError';
    message: Scalars['String']['output'];
};
export type CdnAccessTokenCreateOk = {
    __typename?: 'CdnAccessTokenCreateOk';
    cdnUrl: Scalars['String']['output'];
    createdCdnAccessToken: CdnAccessToken;
    secretAccessToken: Scalars['String']['output'];
};
/** @oneOf */
export type CdnAccessTokenCreateResult = {
    __typename?: 'CdnAccessTokenCreateResult';
    error?: Maybe<CdnAccessTokenCreateError>;
    ok?: Maybe<CdnAccessTokenCreateOk>;
};
export type CdnTokenResult = {
    __typename?: 'CdnTokenResult';
    token: Scalars['String']['output'];
    url: 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 ClientStatsInput = {
    client: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
    period: DateRangeInput;
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['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';
    nodes: Array<ClientStatsValues>;
    total: Scalars['Int']['output'];
};
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 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>;
    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 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>;
    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: Scalars['String']['input'];
    selector: TargetSelectorInput;
};
export type CreateContractInput = {
    contractName: Scalars['String']['input'];
    excludeTags?: InputMaybe<Array<Scalars['String']['input']>>;
    includeTags?: InputMaybe<Array<Scalars['String']['input']>>;
    removeUnreachableTypesFromPublicApiSchema: Scalars['Boolean']['input'];
    targetId: Scalars['ID']['input'];
};
export type CreateContractInputErrors = {
    __typename?: 'CreateContractInputErrors';
    contractName?: Maybe<Scalars['String']['output']>;
    excludeTags?: Maybe<Scalars['String']['output']>;
    includeTags?: Maybe<Scalars['String']['output']>;
    targetId?: Maybe<Scalars['String']['output']>;
};
export type CreateContractResult = {
    __typename?: 'CreateContractResult';
    error?: Maybe<CreateContractResultError>;
    ok?: Maybe<CreateContractResultOk>;
};
export type CreateContractResultError = Error & {
    __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 CreateMemberRoleError = Error & {
    __typename?: 'CreateMemberRoleError';
    /** The detailed validation error messages for the input fields. */
    inputErrors?: Maybe<CreateMemberRoleInputErrors>;
    message: Scalars['String']['output'];
};
export type CreateMemberRoleInput = {
    description: Scalars['String']['input'];
    name: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
    selectedPermissions: Array<Scalars['String']['input']>;
};
export type CreateMemberRoleInputErrors = {
    __typename?: 'CreateMemberRoleInputErrors';
    description?: Maybe<Scalars['String']['output']>;
    name?: Maybe<Scalars['String']['output']>;
};
export type CreateMemberRoleOk = {
    __typename?: 'CreateMemberRoleOk';
    updatedOrganization: Organization;
};
/** @oneOf */
export type CreateMemberRoleResult = {
    __typename?: 'CreateMemberRoleResult';
    error?: Maybe<CreateMemberRoleError>;
    ok?: Maybe<CreateMemberRoleOk>;
};
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 = {
    description?: InputMaybe<Scalars['String']['input']>;
    organization: OrganizationReferenceInput;
    permissions: Array<Scalars['String']['input']>;
    resources: ResourceAssignmentInput;
    title: Scalars['String']['input'];
};
export type CreateOrganizationAccessTokenResult = {
    __typename?: 'CreateOrganizationAccessTokenResult';
    error?: Maybe<CreateOrganizationAccessTokenResultError>;
    ok?: Maybe<CreateOrganizationAccessTokenResultOk>;
};
export type CreateOrganizationAccessTokenResultError = Error & {
    __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 CreateProjectError = Error & {
    __typename?: 'CreateProjectError';
    inputErrors: CreateProjectInputErrors;
    message: Scalars['String']['output'];
};
export type CreateProjectInput = {
    organizationSlug: Scalars['String']['input'];
    slug: Scalars['String']['input'];
    type: ProjectType;
};
export type CreateProjectInputErrors = {
    __typename?: 'CreateProjectInputErrors';
    slug?: Maybe<Scalars['String']['output']>;
};
export type CreateProjectOk = {
    __typename?: 'CreateProjectOk';
    createdProject: Project;
    createdTargets: Array<Target>;
    updatedOrganization: Organization;
};
export type CreateProjectResult = {
    __typename?: 'CreateProjectResult';
    error?: Maybe<CreateProjectError>;
    ok?: Maybe<CreateProjectOk>;
};
export type CreateTargetError = Error & {
    __typename?: 'CreateTargetError';
    inputErrors: CreateTargetInputErrors;
    message: Scalars['String']['output'];
};
export type CreateTargetInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    slug: Scalars['String']['input'];
};
export type CreateTargetInputErrors = {
    __typename?: 'CreateTargetInputErrors';
    slug?: Maybe<Scalars['String']['output']>;
};
export type CreateTargetOk = {
    __typename?: 'CreateTargetOk';
    createdTarget: Target;
    selector: TargetSelector;
};
export type CreateTargetResult = {
    __typename?: 'CreateTargetResult';
    error?: Maybe<CreateTargetError>;
    ok?: Maybe<CreateTargetOk>;
};
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 {
    Breaking = "Breaking",
    Dangerous = "Dangerous",
    Safe = "Safe"
}
export type DateRange = {
    __typename?: 'DateRange';
    from: Scalars['DateTime']['output'];
    to: Scalars['DateTime']['output'];
};
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 DeleteCdnAccessTokenError = Error & {
    __typename?: 'DeleteCdnAccessTokenError';
    message: Scalars['String']['output'];
};
export type DeleteCdnAccessTokenInput = {
    cdnAccessTokenId: Scalars['ID']['input'];
    selector: TargetSelectorInput;
};
export type DeleteCdnAccessTokenOk = {
    __typename?: 'DeleteCdnAccessTokenOk';
    deletedCdnAccessTokenId: Scalars['ID']['output'];
};
/** @oneOf */
export type DeleteCdnAccessTokenResult = {
    __typename?: 'DeleteCdnAccessTokenResult';
    error?: Maybe<DeleteCdnAccessTokenError>;
    ok?: Maybe<DeleteCdnAccessTokenOk>;
};
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 DeleteMemberRoleError = Error & {
    __typename?: 'DeleteMemberRoleError';
    message: Scalars['String']['output'];
};
export type DeleteMemberRoleInput = {
    organizationSlug: Scalars['String']['input'];
    roleId: Scalars['ID']['input'];
};
export type DeleteMemberRoleOk = {
    __typename?: 'DeleteMemberRoleOk';
    updatedOrganization: Organization;
};
/** @oneOf */
export type DeleteMemberRoleResult = {
    __typename?: 'DeleteMemberRoleResult';
    error?: Maybe<DeleteMemberRoleError>;
    ok?: Maybe<DeleteMemberRoleOk>;
};
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 = {
    organizationAccessTokenId: Scalars['ID']['input'];
};
export type DeleteOrganizationAccessTokenResult = {
    __typename?: 'DeleteOrganizationAccessTokenResult';
    error?: Maybe<DeleteOrganizationAccessTokenResultError>;
    ok?: Maybe<DeleteOrganizationAccessTokenResultOk>;
};
export type DeleteOrganizationAccessTokenResultError = Error & {
    __typename?: 'DeleteOrganizationAccessTokenResultError';
    message: Scalars['String']['output'];
};
export type DeleteOrganizationAccessTokenResultOk = {
    __typename?: 'DeleteOrganizationAccessTokenResultOk';
    deletedOrganizationAccessTokenId: Scalars['ID']['output'];
};
export type DeleteOrganizationInvitationError = Error & {
    __typename?: 'DeleteOrganizationInvitationError';
    message: Scalars['String']['output'];
};
export type DeleteOrganizationInvitationInput = {
    email: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
};
/** @oneOf */
export type DeleteOrganizationInvitationResult = {
    __typename?: 'DeleteOrganizationInvitationResult';
    error?: Maybe<DeleteOrganizationInvitationError>;
    ok?: Maybe<OrganizationInvitation>;
};
export type DeleteProjectPayload = {
    __typename?: 'DeleteProjectPayload';
    deletedProject: Project;
    selector: ProjectSelector;
};
export type DeleteSlackIntegrationResult = {
    __typename?: 'DeleteSlackIntegrationResult';
    organization: Organization;
};
export type DeleteTargetPayload = {
    __typename?: 'DeleteTargetPayload';
    deletedTarget: Target;
    selector: TargetSelector;
};
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'];
    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 = {
    contractId: Scalars['ID']['input'];
};
export type DisableContractResult = {
    __typename?: 'DisableContractResult';
    error?: Maybe<DisableContractResultError>;
    ok?: Maybe<DisableContractResultOk>;
};
export type DisableContractResultError = Error & {
    __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'];
    /** Meta information about the schema check. */
    meta?: Maybe<SchemaCheckMeta>;
    /** The previous schema SDL. For composite schemas this is the service. */
    previousSchemaSDL?: Maybe<Scalars['String']['output']>;
    safeSchemaChanges?: Maybe<SchemaChangeConnection>;
    schemaPolicyErrors?: Maybe<SchemaPolicyWarningConnection>;
    schemaPolicyWarnings?: Maybe<SchemaPolicyWarningConnection>;
    /** The SDL of the schema that was checked. */
    schemaSDL: Scalars['String']['output'];
    /**
     * The schema version against this check was performed.
     * Is null if there is no schema version published yet.
     */
    schemaVersion?: Maybe<SchemaVersion>;
    /** The name of the service that owns the schema. Is null for non composite project types. */
    serviceName?: Maybe<Scalars['String']['output']>;
    supergraphSDL?: Maybe<Scalars['String']['output']>;
    /** The URL of the schema check on the Hive Web App. */
    webUrl?: Maybe<Scalars['String']['output']>;
};
export type FailuresOverTime = {
    __typename?: 'FailuresOverTime';
    date: Scalars['DateTime']['output'];
    value: Scalars['SafeInt']['output'];
};
export type FieldListStatsInput = {
    fields: Array<FieldTypePairInput>;
    operationHash?: InputMaybe<Scalars['String']['input']>;
    organizationSlug: Scalars['String']['input'];
    period: DateRangeInput;
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
};
export type FieldStatsInput = {
    argument?: InputMaybe<Scalars['String']['input']>;
    field: Scalars['String']['input'];
    operationHash?: InputMaybe<Scalars['String']['input']>;
    organizationSlug: Scalars['String']['input'];
    period: DateRangeInput;
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
    type: Scalars['String']['input'];
};
export type FieldStatsValues = {
    __typename?: 'FieldStatsValues';
    argument?: Maybe<Scalars['String']['output']>;
    count: Scalars['SafeInt']['output'];
    field: Scalars['String']['output'];
    percentage: Scalars['Float']['output'];
    type: Scalars['String']['output'];
};
export type FieldTypePairInput = {
    argument?: InputMaybe<Scalars['String']['input']>;
    field: Scalars['String']['input'];
    type: Scalars['String']['input'];
};
export type GitHubIntegration = {
    __typename?: 'GitHubIntegration';
    repositories: Array<GitHubRepository>;
};
export type GitHubRepository = {
    __typename?: 'GitHubRepository';
    nameWithOwner: Scalars['String']['output'];
};
export type GitHubSchemaCheckError = {
    __typename?: 'GitHubSchemaCheckError';
    message: Scalars['String']['output'];
};
export type GitHubSchemaCheckInput = {
    commit: Scalars['String']['input'];
    /** The pull request number of the schema check. */
    pullRequestNumber?: InputMaybe<Scalars['String']['input']>;
    /** The repository name of the schema check. */
    repository?: InputMaybe<Scalars['String']['input']>;
};
export type GitHubSchemaCheckSuccess = {
    __typename?: 'GitHubSchemaCheckSuccess';
    message: Scalars['String']['output'];
};
export type GitHubSchemaPublishError = {
    __typename?: 'GitHubSchemaPublishError';
    message: Scalars['String']['output'];
};
export type GitHubSchemaPublishSuccess = {
    __typename?: 'GitHubSchemaPublishSuccess';
    message: Scalars['String']['output'];
};
export type GraphQlArgument = {
    __typename?: 'GraphQLArgument';
    defaultValue?: Maybe<Scalars['String']['output']>;
    deprecationReason?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    isDeprecated: Scalars['Boolean']['output'];
    name: Scalars['String']['output'];
    type: Scalars['String']['output'];
    usage: SchemaCoordinateUsage;
};
export type GraphQlDocument = {
    __typename?: 'GraphQLDocument';
    body: Scalars['String']['output'];
    hash: Scalars['String']['output'];
    /** The internal hash as used for insights. */
    insightsHash: Scalars['String']['output'];
    operationName?: Maybe<Scalars['String']['output']>;
};
export type GraphQlDocumentConnection = {
    __typename?: 'GraphQLDocumentConnection';
    edges: Array<GraphQlDocumentEdge>;
    pageInfo: PageInfo;
};
export type GraphQlDocumentEdge = {
    __typename?: 'GraphQLDocumentEdge';
    cursor: Scalars['String']['output'];
    node: GraphQlDocument;
};
export type GraphQlEnumType = {
    __typename?: 'GraphQLEnumType';
    deprecationReason?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    name: Scalars['String']['output'];
    /**
     * Metadata specific to Apollo Federation Projects.
     * Is null if no meta information is available.
     */
    supergraphMetadata?: Maybe<SupergraphMetadata>;
    usage: SchemaCoordinateUsage;
    values: Array<GraphQlEnumValue>;
};
export type GraphQlEnumValue = {
    __typename?: 'GraphQLEnumValue';
    deprecationReason?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    isDeprecated: Scalars['Boolean']['output'];
    name: Scalars['String']['output'];
    /**
     * Metadata specific to Apollo Federation Projects.
     * Is null if no meta information is available.
     */
    supergraphMetadata?: Maybe<SupergraphMetadata>;
    usage: SchemaCoordinateUsage;
};
export type GraphQlField = {
    __typename?: 'GraphQLField';
    args: Array<GraphQlArgument>;
    deprecationReason?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    isDeprecated: Scalars['Boolean']['output'];
    name: Scalars['String']['output'];
    /**
     * Metadata specific to Apollo Federation Projects.
     * Is null if no meta information is available.
     */
    supergraphMetadata?: Maybe<SupergraphMetadata>;
    type: Scalars['String']['output'];
    usage: SchemaCoordinateUsage;
};
export type GraphQlInputField = {
    __typename?: 'GraphQLInputField';
    defaultValue?: Maybe<Scalars['String']['output']>;
    deprecationReason?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    isDeprecated: Scalars['Boolean']['output'];
    name: Scalars['String']['output'];
    /**
     * Metadata specific to Apollo Federation Projects.
     * Is null if no meta information is available (e.g. this is not an apollo federation project).
     */
    supergraphMetadata?: Maybe<SupergraphMetadata>;
    type: Scalars['String']['output'];
    usage: SchemaCoordinateUsage;
};
export type GraphQlInputObjectType = {
    __typename?: 'GraphQLInputOb