@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> = T | null | undefined;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    Date: {
        input: any;
        output: any;
    };
    /**
     * A date-time string at UTC, such as '2007-12-03T10:15:30Z', is compliant with the date-time format outlined
     * in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.
     *
     * This scalar is a description of an exact instant on the timeline such as the instant that a user account was created.
     *
     * This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
     *
     * Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20+01:00' is shifted to '2016-01-01T13:10:20Z'.
     */
    DateTime: {
        input: any;
        output: any;
    };
    /**
     * A date-time string at UTC with nano-second precision, such as '2007-12-03T10:15:30.123456Z', is compliant with the extended date-time format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. The fractional part of the seconds can range up to nanosecond precision.
     *
     * This scalar represents an exact instant on the timeline, such as the precise moment a user account was created, including fractional seconds.
     *
     * This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
     *
     * Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20.500+01:00' is shifted to '2016-01-01T13:10:20.500Z'.
     */
    DateTime64: {
        input: any;
        output: any;
    };
    JSON: {
        input: any;
        output: any;
    };
    JSONObject: {
        input: any;
        output: any;
    };
    JSONSchemaObject: {
        input: any;
        output: any;
    };
    SafeInt: {
        input: any;
        output: any;
    };
};
/** Interface representing a generic access token. */
export type AccessToken = {
    /** Timestamp indicating when the access token was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional description providing additional context about the access token. */
    description?: Maybe<Scalars['String']['output']>;
    /** The first few characters of the access token, useful for display without exposing the full token. */
    firstCharacters: Scalars['String']['output'];
    /** Unique identifier of the access token. */
    id: Scalars['ID']['output'];
    /** A list of resource levels, their assigned resources, and the granted permissions on each resource. */
    resolvedResourcePermissionGroups: Array<ResolvedResourcePermissionGroup>;
    /** Human-readable title of the access token. */
    title: Scalars['String']['output'];
};
/** Interface representing a generic access token. */
export type AccessTokenResolvedResourcePermissionGroupsArgs = {
    includeAll?: Scalars['Boolean']['input'];
};
export type AccessTokenConnection = {
    __typename?: 'AccessTokenConnection';
    edges: Array<AccessTokenEdge>;
    pageInfo: PageInfo;
};
export type AccessTokenEdge = {
    __typename?: 'AccessTokenEdge';
    cursor: Scalars['String']['output'];
    node: AccessToken;
};
/** Reference input for identifying an access token. */
export type AccessTokenReference = 
/** Select an access token by its unique ID. */
{
    byId: Scalars['ID']['input'];
};
export type ActivateAppDeploymentError = Error & {
    __typename?: 'ActivateAppDeploymentError';
    message: Scalars['String']['output'];
};
export type ActivateAppDeploymentInput = {
    appName: Scalars['String']['input'];
    appVersion: Scalars['String']['input'];
    target?: InputMaybe<TargetReferenceInput>;
};
export type ActivateAppDeploymentOk = {
    __typename?: 'ActivateAppDeploymentOk';
    activatedAppDeployment: AppDeployment;
    /** Whether the app deployment activation was skipped because it is already activated. */
    isSkipped: Scalars['Boolean']['output'];
};
export type ActivateAppDeploymentResult = {
    __typename?: 'ActivateAppDeploymentResult';
    error?: Maybe<ActivateAppDeploymentError>;
    ok?: Maybe<ActivateAppDeploymentOk>;
};
export type AddAlertChannelError = Error & {
    __typename?: 'AddAlertChannelError';
    inputErrors: AddAlertChannelInputErrors;
    message: Scalars['String']['output'];
};
export type AddAlertChannelInput = {
    name: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    slack?: InputMaybe<SlackChannelInput>;
    type: AlertChannelType;
    webhook?: InputMaybe<WebhookChannelInput>;
};
export type AddAlertChannelInputErrors = {
    __typename?: 'AddAlertChannelInputErrors';
    name?: Maybe<Scalars['String']['output']>;
    slackChannel?: Maybe<Scalars['String']['output']>;
    webhookEndpoint?: Maybe<Scalars['String']['output']>;
};
export type AddAlertChannelOk = {
    __typename?: 'AddAlertChannelOk';
    addedAlertChannel: AlertChannel;
    updatedProject: Project;
};
export type AddAlertChannelResult = {
    __typename?: 'AddAlertChannelResult';
    error?: Maybe<AddAlertChannelError>;
    ok?: Maybe<AddAlertChannelOk>;
};
export type AddAlertError = Error & {
    __typename?: 'AddAlertError';
    message: Scalars['String']['output'];
};
export type AddAlertInput = {
    channelId: Scalars['ID']['input'];
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
    type: AlertType;
};
export type AddAlertOk = {
    __typename?: 'AddAlertOk';
    addedAlert: Alert;
    updatedProject: Project;
};
export type AddAlertResult = {
    __typename?: 'AddAlertResult';
    error?: Maybe<AddAlertError>;
    ok?: Maybe<AddAlertOk>;
};
export type AddDocumentsToAppDeploymentError = Error & {
    __typename?: 'AddDocumentsToAppDeploymentError';
    /** Optional details if the error is related to a specific document. */
    details?: Maybe<AddDocumentsToAppDeploymentErrorDetails>;
    message: Scalars['String']['output'];
};
export type AddDocumentsToAppDeploymentErrorDetails = {
    __typename?: 'AddDocumentsToAppDeploymentErrorDetails';
    /** Index of the document sent from the client. */
    index: Scalars['Int']['output'];
    /** Error message for the document at the given index. */
    message: Scalars['String']['output'];
};
export type AddDocumentsToAppDeploymentInput = {
    /** Name of the app. */
    appName: Scalars['String']['input'];
    /** The version of the app */
    appVersion: Scalars['String']['input'];
    /** A list of operations to add to the app deployment. (max 100 per single batch) */
    documents: Array<DocumentInput>;
    target?: InputMaybe<TargetReferenceInput>;
};
export type AddDocumentsToAppDeploymentOk = {
    __typename?: 'AddDocumentsToAppDeploymentOk';
    appDeployment: AppDeployment;
};
export type AddDocumentsToAppDeploymentResult = {
    __typename?: 'AddDocumentsToAppDeploymentResult';
    error?: Maybe<AddDocumentsToAppDeploymentError>;
    ok?: Maybe<AddDocumentsToAppDeploymentOk>;
};
export type AddGitHubIntegrationInput = {
    installationId: Scalars['ID']['input'];
    organizationSlug: Scalars['String']['input'];
};
export type AddSlackIntegrationInput = {
    organizationSlug: Scalars['String']['input'];
    token: Scalars['String']['input'];
};
export type AdminGeneralStats = {
    __typename?: 'AdminGeneralStats';
    operationsOverTime: Array<AdminOperationPoint>;
};
export type AdminOperationPoint = {
    __typename?: 'AdminOperationPoint';
    count: Scalars['SafeInt']['output'];
    date: Scalars['DateTime']['output'];
};
export type AdminOrganizationStats = {
    __typename?: 'AdminOrganizationStats';
    operations: Scalars['SafeInt']['output'];
    organization: Organization;
    persistedOperations: Scalars['Int']['output'];
    projects: Scalars['Int']['output'];
    targets: Scalars['Int']['output'];
    users: Scalars['Int']['output'];
    versions: Scalars['Int']['output'];
};
export type AdminQuery = {
    __typename?: 'AdminQuery';
    stats: AdminStats;
};
export type AdminQueryStatsArgs = {
    period: DateRangeInput;
    resolution: Scalars['Int']['input'];
};
export type AdminStats = {
    __typename?: 'AdminStats';
    general: AdminGeneralStats;
    organizations: Array<AdminOrganizationStats>;
};
export type Alert = {
    __typename?: 'Alert';
    channel: AlertChannel;
    id: Scalars['ID']['output'];
    target: Target;
    type: AlertType;
};
export type AlertChannel = {
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    type: AlertChannelType;
};
export declare enum AlertChannelType {
    MsteamsWebhook = "MSTEAMS_WEBHOOK",
    Slack = "SLACK",
    Webhook = "WEBHOOK"
}
export type AlertSlackChannel = AlertChannel & {
    __typename?: 'AlertSlackChannel';
    channel: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    type: AlertChannelType;
};
export declare enum AlertType {
    SchemaChangeNotifications = "SCHEMA_CHANGE_NOTIFICATIONS"
}
export type AlertWebhookChannel = AlertChannel & {
    __typename?: 'AlertWebhookChannel';
    endpoint: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    type: AlertChannelType;
};
export type AnswerOrganizationTransferRequestError = Error & {
    __typename?: 'AnswerOrganizationTransferRequestError';
    message: Scalars['String']['output'];
};
export type AnswerOrganizationTransferRequestInput = {
    accept: Scalars['Boolean']['input'];
    code: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
};
export type AnswerOrganizationTransferRequestOk = {
    __typename?: 'AnswerOrganizationTransferRequestOk';
    accepted: Scalars['Boolean']['output'];
};
/** @oneOf */
export type AnswerOrganizationTransferRequestResult = {
    __typename?: 'AnswerOrganizationTransferRequestResult';
    error?: Maybe<AnswerOrganizationTransferRequestError>;
    ok?: Maybe<AnswerOrganizationTransferRequestOk>;
};
export type AppDeployment = {
    __typename?: 'AppDeployment';
    documents?: Maybe<GraphQlDocumentConnection>;
    id: Scalars['ID']['output'];
    /** The last time a GraphQL request that used the app deployment was reported. */
    lastUsed?: Maybe<Scalars['DateTime']['output']>;
    name: Scalars['String']['output'];
    status: AppDeploymentStatus;
    totalDocumentCount: Scalars['Int']['output'];
    version: Scalars['String']['output'];
};
export type AppDeploymentDocumentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<AppDeploymentDocumentsFilterInput>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type AppDeploymentConnection = {
    __typename?: 'AppDeploymentConnection';
    edges: Array<AppDeploymentEdge>;
    pageInfo: PageInfo;
};
export type AppDeploymentDocumentsFilterInput = {
    operationName?: InputMaybe<Scalars['String']['input']>;
};
export type AppDeploymentEdge = {
    __typename?: 'AppDeploymentEdge';
    cursor: Scalars['String']['output'];
    node: AppDeployment;
};
export type AppDeploymentOperation = {
    /** GraphQL operation body. */
    body: Scalars['String']['input'];
    /** GraphQL operation hash. */
    hash: Scalars['String']['input'];
};
export type AppDeploymentResourceAssignmentInput = {
    appDeployment: Scalars['String']['input'];
};
export declare enum AppDeploymentStatus {
    Active = "active",
    Pending = "pending",
    Retired = "retired"
}
export type ApproveFailedSchemaCheckError = {
    __typename?: 'ApproveFailedSchemaCheckError';
    message: Scalars['String']['output'];
};
export type ApproveFailedSchemaCheckInput = {
    author?: InputMaybe<Scalars['String']['input']>;
    /**
     * 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>;
};
/** Metadata for approvals made via CLI. */
export type CliApprovalMetadata = {
    __typename?: 'CLIApprovalMetadata';
    /** Raw author string from the CLI. */
    author: Scalars['String']['output'];
    /** Parsed display name from the author string. */
    displayName: Scalars['String']['output'];
    /** Parsed email from the author string (if available). */
    email?: Maybe<Scalars['String']['output']>;
};
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>;
};
/** Input for creating a new organization-scoped access token. */
export type CreateOrganizationAccessTokenInput = {
    /** Optional description providing additional context about the purpose of the access token. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The organization in which the access token should be created. */
    organization: OrganizationReferenceInput;
    /**
     * List of permissions assigned to the access token.
     * Available permissions can be retrieved via the
     * 'Organization.availableOrganizationAccessTokenPermissionGroups' field.
     */
    permissions: Array<Scalars['String']['input']>;
    /**
     * Resources on which the permissions should be granted (e.g., project, target, service, or app deployments).
     * Permissions are inherited by sub-resources.
     */
    resources: ResourceAssignmentInput;
    /** Human-readable title for the access token. */
    title: Scalars['String']['input'];
};
/** Result returned after attempting to create an organization access token. */
export type CreateOrganizationAccessTokenResult = {
    __typename?: 'CreateOrganizationAccessTokenResult';
    /** Contains error information if the creation failed. */
    error?: Maybe<CreateOrganizationAccessTokenResultError>;
    /** Indicates a successful creation. */
    ok?: Maybe<CreateOrganizationAccessTokenResultOk>;
};
/** Payload returned when organization access token creation fails. */
export type CreateOrganizationAccessTokenResultError = {
    __typename?: 'CreateOrganizationAccessTokenResultError';
    /** Field-specific validation error details, if any. */
    details?: Maybe<CreateOrganizationAccessTokenResultErrorDetails>;
    /** A human-readable message describing the reason for the failure. */
    message: Scalars['String']['output'];
};
/** Field-level validation error details for organization access token creation. */
export type CreateOrganizationAccessTokenResultErrorDetails = {
    __typename?: 'CreateOrganizationAccessTokenResultErrorDetails';
    /** Validation error message related to the provided description. */
    description?: Maybe<Scalars['String']['output']>;
    /** Validation error message related to the provided title. */
    title?: Maybe<Scalars['String']['output']>;
};
/** Payload returned on successful organization access token creation. */
export type CreateOrganizationAccessTokenResultOk = {
    __typename?: 'CreateOrganizationAccessTokenResultOk';
    /** The newly created organization access token. */
    createdOrganizationAccessToken: OrganizationAccessToken;
    /**
     * The private access key corresponding to the new token.
     * This value is only returned once at creation time and cannot be retrieved later.
     */
    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>;
};
/** Input for creating a new personal access token. */
export type CreatePersonalAccessTokenInput = {
    /** Optional description providing additional context about the purpose of the access token. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The organization in which the access token should be created. */
    organization: OrganizationReferenceInput;
    /**
     * List of permissions assigned to the access token.
     * A list of available permissions can be retrieved via the
     * 'Member.availablePersonalAccessTokenPermissionGroups' field.
     */
    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
    /**
     * Resources on which the permissions should be granted (e.g., project, target, service, or app deployments).
     * Permissions are inherited by sub-resources.
     */
    resources?: InputMaybe<ResourceAssignmentInput>;
    /** Human-readable title for the access token. */
    title: Scalars['String']['input'];
};
/** Top-level result object for creating a personal access token. */
export type CreatePersonalAccessTokenResult = {
    __typename?: 'CreatePersonalAccessTokenResult';
    /** Contains error information if the creation failed. */
    error?: Maybe<CreatePersonalAccessTokenResultError>;
    /** Indicates a successful creation. */
    ok?: Maybe<CreatePersonalAccessTokenResultOk>;
};
/** Result returned when the creation of a personal access token fails. */
export type CreatePersonalAccessTokenResultError = {
    __typename?: 'CreatePersonalAccessTokenResultError';
    /** Field-specific validation error details, if any. */
    details?: Maybe<CreatePersonalAccessTokenResultErrorDetails>;
    /** A human-readable message describing the reason for the failure. */
    message: Scalars['String']['output'];
};
/** Field-level validation error details for personal access token creation. */
export type CreatePersonalAccessTokenResultErrorDetails = {
    __typename?: 'CreatePersonalAccessTokenResultErrorDetails';
    /** Validation error message related to the provided description. */
    description?: Maybe<Scalars['String']['output']>;
    /** Validation error message related to the provided title. */
    title?: Maybe<Scalars['String']['output']>;
};
/** Result returned when the creation of a personal access token succeeds. */
export type CreatePersonalAccessTokenResultOk = {
    __typename?: 'CreatePersonalAccessTokenResultOk';
    /** The newly created personal access token. */
    createdPersonalAccessToken: PersonalAccessToken;
    /**
     * The private access key corresponding to the new token.
     * This value is only returned once at creation time and cannot be retrieved later.
     */
    privateAccessKey: Scalars['String']['output'];
};
/** Input for creating a new project-scoped access token. */
export type CreateProjectAccessTokenInput = {
    /** Optional description providing additional context about the purpose of the access token. */
    description?: InputMaybe<Scalars['String']['input']>;
    /**
     * List of permissions assigned to the access token.
     * Available permissions can be retrieved via the
     * 'Project.availableProjectAccessTokenPermissionGroups' field.
     */
    permissions: Array<Scalars['String']['input']>;
    /** The project in which the access token should be created. */
    project: ProjectReferenceInput;
    /**
     * Resources on which the permissions should be granted (e.g.,  target, service, or app deployments).
     * Permissions are inherited by sub-resources.
     */
    resources: ProjectTargetsResourceAssignmentInput;
    /** Human-readable title for the access token. */
    title: Scalars['String']['input'];
};
/**
 * Top-level result object for creating a project access token.
 *
 * @oneOf
 */
export type CreateProjectAccessTokenResult = {
    __typename?: 'CreateProjectAccessTokenResult';
    /** Contains error information if the creation failed. */
    error?: Maybe<CreateProjectAccessTokenResultError>;
    /** Indicates a successful creation. */
    ok?: Maybe<CreateProjectAccessTokenResultOk>;
};
/** Result returned when the creation of a project access token fails. */
export type CreateProjectAccessTokenResultError = {
    __typename?: 'CreateProjectAccessTokenResultError';
    /** Field-specific validation error details, if any. */
    details?: Maybe<CreateProjectAccessTokenResultErrorDetails>;
    /** A human-readable message describing the reason for the failure. */
    message?: Maybe<Scalars['String']['output']>;
};
/** Field-level validation error details for project access token creation. */
export type CreateProjectAccessTokenResultErrorDetails = {
    __typename?: 'CreateProjectAccessTokenResultErrorDetails';
    /** Validation error message related to the provided description. */
    description?: Maybe<Scalars['String']['output']>;
    /** Validation error message related to the provided title. */
    title?: Maybe<Scalars['String']['output']>;
};
/** Result returned when the creation of a project access token succeeds. */
export type CreateProjectAccessTokenResultOk = {
    __typename?: 'CreateProjectAccessTokenResultOk';
    /** The newly created project access token. */
    createdProjectAccessToken: ProjectAccessToken;
    /**
     * The private access key corresponding to the new token.
     * This value is only returned once at creation time and cannot be retrieved later.
     */
    privateAccessKey: Scalars['String']['output'];
};
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'];
};
/** Input for deleting an access token. */
export type DeleteAccessTokenInput = {
    /** Reference to the access token that should be deleted. */
    accessToken: AccessTokenReference;
};
/** Result returned after attempting to delete an access token. */
export type DeleteAccessTokenResult = {
    __typename?: 'DeleteAccessTokenResult';
    /** Contains error information if the deletion failed. */
    error?: Maybe<DeleteAccessTokenResultError>;
    /** Indicates a successful deletion. */
    ok?: Maybe<DeleteAccessTokenResultOk>;
};
/** Payload returned when access token deletion fails. */
export type DeleteAccessTokenResultError = {
    __typename?: 'DeleteAccessTokenResultError';
    /** A human-readable message describing the reason for the failure. */
    message: Scalars['String']['output'];
};
/** Payload returned on successful access token deletion. */
export type DeleteAccessTokenResultOk = {
    __typename?: 'DeleteAccessTokenResultOk';
    /** The unique ID of the access token that was deleted. */
    deletedAccessTokenId: Scalars['ID']['output'];
};
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 DeleteOidcI