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']>;
    /** If set, then this is when the token will expire and become invalid. */
    expiresAt?: Maybe<Scalars['DateTime']['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>;
};
/**
 * Filter options for querying active app deployments.
 * The date filters (lastUsedBefore, neverUsedAndCreatedBefore) use OR semantics:
 * a deployment is included if it matches either date condition.
 * If no date filters are provided, all active deployments are returned.
 */
export type ActiveAppDeploymentsFilter = {
    /**
     * Returns deployments that were last used before the given timestamp.
     * Useful for identifying stale or inactive deployments that have been used
     * at least once but not recently.
     */
    lastUsedBefore?: InputMaybe<Scalars['DateTime']['input']>;
    /**
     * Filter by app deployment name. Case-insensitive partial match.
     * Applied with AND semantics to narrow down results.
     */
    name?: InputMaybe<Scalars['String']['input']>;
    /**
     * Returns deployments that have never been used and were created before
     * the given timestamp. Useful for identifying old, unused deployments
     * that may be candidates for cleanup.
     */
    neverUsedAndCreatedBefore?: InputMaybe<Scalars['DateTime']['input']>;
};
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 AddMetricAlertRuleError = Error & {
    __typename?: 'AddMetricAlertRuleError';
    message: Scalars['String']['output'];
};
export type AddMetricAlertRuleInput = {
    channelIds: Array<Scalars['ID']['input']>;
    confirmationMinutes?: InputMaybe<Scalars['Int']['input']>;
    direction: MetricAlertRuleDirection;
    metric?: InputMaybe<MetricAlertRuleMetric>;
    name: Scalars['String']['input'];
    savedFilterId?: InputMaybe<Scalars['ID']['input']>;
    severity: MetricAlertRuleSeverity;
    target: TargetReferenceInput;
    thresholdType: MetricAlertRuleThresholdType;
    thresholdValue: Scalars['Float']['input'];
    timeWindowMinutes: Scalars['Int']['input'];
    type: MetricAlertRuleType;
};
export type AddMetricAlertRuleOk = {
    __typename?: 'AddMetricAlertRuleOk';
    addedMetricAlertRule: MetricAlertRule;
    /**
     * The target that owns the new rule. Returned so urql's cache can invalidate
     * Target.metricAlertRules after a successful create, mirroring how
     * addAlert/addAlertChannel return updatedProject for the same reason.
     */
    updatedTarget: Target;
};
export type AddMetricAlertRuleResult = {
    __typename?: 'AddMetricAlertRuleResult';
    error?: Maybe<AddMetricAlertRuleError>;
    ok?: Maybe<AddMetricAlertRuleOk>;
};
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';
    /** The timestamp when the app deployment was activated. */
    activatedAt?: Maybe<Scalars['DateTime']['output']>;
    /** The timestamp when the app deployment was created. */
    createdAt: Scalars['DateTime']['output'];
    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'];
    /** The timestamp when the app deployment was retired. Only present for retired deployments. */
    retiredAt?: Maybe<Scalars['DateTime']['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;
    /** The total number of app deployments for this target. */
    total: Scalars['Int']['output'];
};
export type AppDeploymentDocumentsFilterInput = {
    operationName?: InputMaybe<Scalars['String']['input']>;
    /** Filter documents that use any of the specified schema coordinates. */
    schemaCoordinates?: InputMaybe<Array<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'];
};
/** Details about why protection prevented retirement. */
export type AppDeploymentProtectionBlockDetails = {
    __typename?: 'AppDeploymentProtectionBlockDetails';
    /** Current traffic percentage of this app deployment. */
    currentTrafficPercentage?: Maybe<Scalars['Float']['output']>;
    /** Days since the app deployment was last used. */
    daysSinceLastUsed?: Maybe<Scalars['Int']['output']>;
    /** The last time the app deployment was used. */
    lastUsed?: Maybe<Scalars['DateTime']['output']>;
    /** Maximum traffic percentage allowed for retirement. */
    maxTrafficPercentage: Scalars['Float']['output'];
    /** Required minimum days of inactivity. */
    requiredMinDaysInactive: Scalars['Int']['output'];
};
/** Configuration for app deployment retirement protection. */
export type AppDeploymentProtectionConfiguration = {
    __typename?: 'AppDeploymentProtectionConfiguration';
    /** Whether app deployment protection is enabled. */
    isEnabled: Scalars['Boolean']['output'];
    /** Maximum traffic percentage threshold. App deployments with traffic above this percentage cannot be retired. */
    maxTrafficPercentage: Scalars['Float']['output'];
    /** Minimum number of days an app deployment must be inactive before it can be retired. */
    minDaysInactive: Scalars['Int']['output'];
    /** Minimum number of days since creation before an app deployment can be retired. */
    minDaysSinceCreation: Scalars['Int']['output'];
    /** Logic to apply between the inactivity and traffic rules. AND requires both conditions, OR requires either. */
    ruleLogic: AppDeploymentProtectionRuleLogicType;
    /** Number of days to look back when calculating traffic percentage. */
    trafficPeriodDays: Scalars['Int']['output'];
};
/**
 * Input for updating app deployment protection configuration.
 * Fields not provided (omitted) will retain the previous value.
 */
export type AppDeploymentProtectionConfigurationInput = {
    /** Enable or disable app deployment protection. */
    isEnabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Maximum traffic percentage allowed for retirement (0-100). */
    maxTrafficPercentage?: InputMaybe<Scalars['Float']['input']>;
    /** Minimum days of inactivity required before retirement (must be >= 0). */
    minDaysInactive?: InputMaybe<Scalars['Int']['input']>;
    /** Minimum days since creation before retirement (must be >= 0). */
    minDaysSinceCreation?: InputMaybe<Scalars['Int']['input']>;
    /** Logic to apply between the inactivity and traffic rules. */
    ruleLogic?: InputMaybe<AppDeploymentProtectionRuleLogicType>;
    /** Number of days to look back when calculating traffic percentage (must be >= 1). */
    trafficPeriodDays?: InputMaybe<Scalars['Int']['input']>;
};
/** Logic type for combining app deployment protection rules. */
export declare enum AppDeploymentProtectionRuleLogicType {
    /** Both conditions must be met (inactive days AND low traffic). */
    And = "AND",
    /** Either condition can be met (inactive days OR low traffic). */
    Or = "OR"
}
export type AppDeploymentResourceAssignmentInput = {
    appDeployment: Scalars['String']['input'];
};
export declare enum AppDeploymentStatus {
    Active = "active",
    Pending = "pending",
    Retired = "retired"
}
/** Fields available for sorting app deployments. */
export declare enum AppDeploymentsSortField {
    ActivatedAt = "ACTIVATED_AT",
    CreatedAt = "CREATED_AT",
    LastUsed = "LAST_USED"
}
/** Sort configuration for app deployments. */
export type AppDeploymentsSortInput = {
    direction: SortDirectionType;
    field: AppDeploymentsSortField;
};
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 ClientFilter = {
    __typename?: 'ClientFilter';
    name: Scalars['String']['output'];
    versions?: Maybe<Array<Scalars['String']['output']>>;
};
export type ClientFilterInput = {
    name: Scalars['String']['input'];
    versions?: InputMaybe<Array<Scalars['String']['input']>>;
};
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;
};
/** Filter by specific client name + version combinations. */
export type ClientVersionFilterInput = {
    /** The client name to filter by. */
    clientName: Scalars['String']['input'];
    /**
     * Specific versions of this client to include.
     * When null, all versions of this client are included.
     */
    versions?: InputMaybe<Array<Scalars['String']['input']>>;
};
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 app deployment names that are excluded from the breaking change detection. */
    excludedAppDeployments: Array<Scalars['String']['output']>;
    /** 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 app deployment names that are excluded from the breaking change detection. */
    excludedAppDeployments?: InputMaybe<Array<Scalars['String']['input']>>;
    /** 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';
    additionalScopes?: Maybe<Scalars['String']['output']>;
    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 = {
    additionalScopes: Array<Scalars['String']['input']>;
    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']>;
    /** Set this in order to automatically expire this token after a period of time. */
    expirationPeriod?: InputMaybe<TokenExpirationPeriod>;
    /** 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']>;
    /** Set this in order to automatically expire this token after a period of time. */
    expirationPeriod?: InputMaybe<TokenExpirationPeriod>;
    /** 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']>;
    /** Set this in order to automatically expire this token after a period of time. */
    expirationPeriod?: InputMaybe<TokenExpirationPeriod>;
    /**
     * 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 CreateSavedFilterInput = {
    description?: InputMaybe<Scalars['String']['input']>;
    insightsFilter?: InputMaybe<InsightsFilterConfigurationInput>;
    name: Scalars['String']['input'];
    target: TargetReferenceInput;
    visibility: SavedFilterVisibilityType;
};
export type CreateSavedFilterOkPayload = {
    __typename?: 'CreateSavedFilterOkPayload';
    savedFilter: SavedFilter;
};
/** @oneOf */
export type CreateSavedFilterResult = {
    __typename?: 'CreateSavedFilterResult';
    error?: Maybe<SavedFilterError>;
    ok?: Maybe<CreateSavedFilterOkPayload>;
};
export type CreateSchemaProposalError = Error & {
    __typename?: 'CreateSchemaProposalError';
    details: CreateSchemaProposalErrorDetails;
    message: Scalars['String']['output'];
};
export type CreateSchemaProposalErrorDetails = {
    __typename?: 'CreateSchemaProposalErrorDetails';
    /** Error message for the input description. */
    description?: Maybe<Scalars['String']['output']>;
    /** Error message for the input title. */
    title?: Maybe<Scalars['String']['output']>;
};
export type CreateSchemaProposalInput = {
    /** Display name of the person who initially created this proposal */
    author: Scalars['String']['input'];
    /** If no description was provided then this will be an empty string. */
    description?: Scalars['String']['input'];
    /**
     * The default initial stage is OPEN. Set this to true to create this as proposal
     * as a DRAFT instead.
     */
    isDraft?: Scalars['Boolean']['input'];
    /** Reference to the proposal's target. Either an ID or path. */
    target: TargetReferenceInput;
    /** The title of the proposal. A short description of the proposal's main focus/theme. */
    title: Scalars['String']['input'];
};
export type CreateSchemaProposalOk = {
    __typename?: 'CreateSchemaProposalOk';
    schemaProposal: SchemaProposal;
};
export type CreateSchemaProposalResult = {
    __typename?: 'CreateSchemaProposalResult';
    error?: Maybe<CreateSchemaProposalError>;
    ok?: Maybe<CreateSchemaProposalOk>;
};
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 = {
    expirationPeriod?: TokenExpirationPeriod;
    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 DeleteMetricAlertRulesError = Error & {
    __typename?: 'DeleteMetricAlertRulesError';
    message: Scalars['String']['output'];
};
export type DeleteMetricAlertRulesInput = {
    project: ProjectReferenceInput;
    ruleIds: Array<Scalars['ID']['input']>;
};
export type DeleteMetricAlertRulesOk = {
    __typename?: 'DeleteMetricAlertRulesOk';
    deletedMetricAlertRuleIds: Array<Scalars['ID']['output']>;
};
export type DeleteMetricAlertRulesResult = {
    __typename?: 'DeleteMetricAlertRulesResult';
    error?: Maybe<DeleteMetricAlertRulesError>;
    ok?: Maybe<DeleteMetricAlertRulesOk>;
};
export type DeleteOidcDomainError = {
    __typename?: 'DeleteOIDCDomainError';
    message: Scalars['String']['output'];
};
export type DeleteOidcDomainInput = {
    oidcDomainId: Scalars['ID']['input'];
};
export type DeleteOidcDomainOk = {
    __typename?: 'DeleteOIDCDomainOk';
    deletedOIDCIntegrationId: Scalars['ID']['output'];
    oidcIntegration?: Maybe<OidcIntegration>;
};
export type DeleteOidcDomainResult = {
    __typename?: 'DeleteOIDCDomainResult';
    error?: Maybe<DeleteOidcDomainError>;
    ok?: Maybe<DeleteOidcDomainOk>;
};
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>;
};
/** Input for deleting an existing organization access token. */
export type DeleteOrganizationAccessTokenInput = {
    /** Reference to the organization access token that should be deleted. */
    organizationAccessToken: OrganizationAccessTokenReference;
};
/** Result returned after attempting to delete an organization access token. */
export type DeleteOrganizationAccessTokenResult = {
    __typename?: 'DeleteOrganizationAccessTokenResult';
    /** Contains error details if the deletion failed. */
    error?: Maybe<DeleteOrganizationAccessTokenResultError>;
    /** Indicates a successful deletion. */
    ok?: Maybe<DeleteOrganizationAccessTokenResultOk>;
};
/** Payload returned when an organization access token deletion fails. */
export type DeleteOrganizationAccessTokenResultError = {
    __typename?: 'DeleteOrganizationAccessTokenResultError';
    /** A human-readable message describing the reason for the failure. */
    message: Scalars['String']['output'];
};
/** Payload returned on successful organization access token deletion. */
export type DeleteOrganizationAccessTokenResultOk = {
    __typename?: 'DeleteOrganizationAccessTokenResultOk';
    /** The ID of the organization access token that was deleted. */
    deletedOrganizationAccessTokenId: Scalars['ID']['output'];
};
export type DeleteOrganizationInvitationInput = {
    email: Scalars['String']['input'];
    organization: OrganizationReferenceInput;
};
/** @oneOf */
export type DeleteOrganizationInvitationResult = {
    __typename?: 'DeleteOrganizationInvitationResult';
    error?: Maybe<DeleteOrganizationInvitationResultError>;
    ok?: Maybe<DeleteOrganizationInvitationResultOk>;
};
export type DeleteOrganizationInvitationResultError = {
    __typename?: 'DeleteOrganizationInvitationResultError';
    message: Scalars['String']['output'];
};
export type DeleteOrganizationInvitationResultOk = {
    __typename?: 'DeleteOrganizationInvitationResultOk';
    deletedOrganizationInvitationId: Scalars['ID']['output'];
};
export type DeleteProjectInput = {
    project: ProjectReferenceInput;
};
export type DeleteProjectResult = {
    __typename?: 'DeleteProjectResult';
    error?: Maybe<DeleteProjectResultError>;
    ok?: Maybe<DeleteProjectResultOk>;
};
export type DeleteProjectResultError = {
    __typename?: 'DeleteProjectResultError';
    message: Scalars['String']['output'];
};
export type DeleteProjectResultOk = {
    __typename?: 'DeleteProjectResultOk';
    deletedProjectId: Scalars['ID']['output'];
};
export type DeleteSavedFilterInput = {
    id: Scalars['ID']['input'];
    target: TargetReferenceInput;
};
export type DeleteSavedFilterOkPayload = {
    __typename?: 'DeleteSavedFilterOkPayload';
    deletedId: Scalars['ID']['output'];
};
/** @oneOf */
export type DeleteSavedFilterResult = {
    __typename?: 'DeleteSavedFilterResult';
    error?: Maybe<SavedFilterError>;
    ok?: Maybe<DeleteSavedFilterOkPayload>;
};
export type DeleteSlackIntegrationResult = {
    __typename?: 'DeleteSlackIntegrationResult';
    organization: Organization;
};
export type DeleteTargetInput = {
    /** Reference to the target that should be deleted. */
    target: TargetReferenceInput;
};
export type DeleteTargetPayload = {
    __typename?: 'DeleteTargetPayload';
    deletedTarget: Target;
    selector: TargetSelector;
};
export type DeleteTargetResult = {
    __typename?: 'DeleteTargetResult';
    error?: Maybe<DeleteTargetResultError>;
    ok?: Maybe<DeleteTargetResultOk>;
};
export type DeleteTargetResultError = {
    __typename?: 'DeleteTargetResultError';
    message: Scalars['String']['output'];
};
export type DeleteTargetResultOk = {
    __typename?: 'DeleteTargetResultOk';
    deletedTargetId: Scalars['ID']['output'];
};
export type DeleteTokensInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
    tokenIds: Array<Scalars['ID']['input']>;
};
export type DeleteTokensPayload = {
    __typename?: 'DeleteTokensPayload';
    deletedTokens: Array<Scalars['ID']['output']>;
    selector: TargetSelector;
};
export type DeletedSchemaLog = {
    __typename?: 'DeletedSchemaLog';
    date: Scalars['DateTime']['output'];
    /** The name of the service that got deleted. */
    deletedService: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** The previous SDL of the full schema or subgraph. */
    previousServiceSdl?: Maybe<Scalars['String']['output']>;
};
/** Explorer for navigating the deprecated schema parts with usage data provided by the contextual period. */
export type DeprecatedSchemaExplorer = {
    __typename?: 'DeprecatedSchemaExplorer';
    /**
     * The affected types whose fields/values/members are deprecated.
     *
     * The types within the result only contain deprecated fields/values/members, all other entities are excluded,
     * they are not a representation of the full GraphQL schema.
     */
    types: Array<GraphQlNamedType>;
};
export type DirectiveAdded = {
    __typename?: 'DirectiveAdded';
    addedDirectiveDescription?: Maybe<Scalars['String']['output']>;
    addedDirectiveLocations: Array<Scalars['String']['output']>;
    addedDirectiveName: Scalars['String']['output'];
    addedDirectiveRepeatable?: Maybe<Scalars['Boolean']['output']>;
};
export type DirectiveArgumentAdded = {
    __typename?: 'DirectiveArgumentAdded';
    addedDirectiveArgumentDescription?: Maybe<Scalars['String']['output']>;
    addedDirectiveArgumentName: Scalars['String']['output'];
    addedDirectiveArgumentType: Scalars['String']['output'];
    addedDirectiveArgumentTypeIsNonNull?: Maybe<Scalars['Boolean']['output']>;
    addedDirectiveDefaultValue?: Maybe<Scalars['String']['output']>;
    addedToNewDirective?: Maybe<Scalars['Boolean']['output']>;
    directiveName: Scalars['String']['output'];
};
export type DirectiveArgumentDefaultValueChanged = {
    __typename?: 'DirectiveArgumentDefaultValueChanged';
    directiveArgumentName: Scalars['String']['output'];
    directiveName: Scalars['String']['output'];
    newDirectiveArgumentDefaultValue?: Maybe<Scalars['String']['output']>;
    oldDirectiveArgumentDefaultValue?: Maybe<Scalars['String']['output']>;
};
export type DirectiveArgumentDescriptionChanged = {
    __typename?: 'DirectiveArgumentDescriptionChanged';
    directiveArgumentName: Scalars['String']['output'];
    directiveName: Scalars['String']['output'];
    newDirectiveArgumentDescription?: Maybe<Scalars['String']['output']>;
    oldDirectiveArgumentDescription?: Maybe<Scalars['String']['output']>;
};
export type DirectiveArgumentRemoved = {
    __typename?: 'DirectiveArgumentRemoved';
    directiveName: Scalars['String']['output'];
    removedDirectiveArgumentName: Scalars['String']['output'];
};
export type DirectiveArgumentTypeChanged = {
    __typename?: 'DirectiveArgumentTypeChanged';
    directiveArgumentName: Scalars['String']['output'];
    directiveName: Scalars['String']['output'];
    isSafeDirectiveArgumentTypeChange?: Maybe<Scalars['Boolean']['output']>;
    newDirectiveArgumentType: Scalars['String']['output'];
    oldDirectiveArgumentType: Scalars['String']['output'];
};
export type DirectiveDescriptionChanged = {
    __typename?: 'DirectiveDescriptionChanged';
    directiveName: Scalars['String']['output'];
    newDirectiveDescription?: Maybe<Scalars['String']['output']>;
    oldDirectiveDescription?: Maybe<Scalars['String']['output']>;
};
export type DirectiveLocationAdded = {
    __typename?: 'DirectiveLocationAdded';
    addedDirectiveLocation: Scalars['String']['output'];
    directiveName: Scalars['String']['output'];
};
export type DirectiveLocationRemoved = {
    __typename?: 'DirectiveLocationRemoved';
    directiveName: Scalars['String']['output'];
    removedDirectiveLocation: Scalars['String']['output'];
};
export type DirectiveRemoved = {
    __typename?: 'DirectiveRemoved';
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveRepeatableAdded = {
    __typename?: 'DirectiveRepeatableAdded';
    directiveName: Scalars['String']['output'];
};
export type DirectiveRepeatableRemoved = {
    __typename?: 'DirectiveRepeatableRemoved';
    directiveName: Scalars['String']['output'];
};
export type DirectiveUsageArgumentAdded = {
    __typename?: 'DirectiveUsageArgumentAdded';
    addedArgumentName: Scalars['String']['output'];
    addedArgumentValue: Scalars['String']['output'];
    directiveName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    oldArgumentValue?: Maybe<Scalars['String']['output']>;
    parentArgumentName?: Maybe<Scalars['String']['output']>;
    parentEnumValueName?: Maybe<Scalars['String']['output']>;
    parentFieldName?: Maybe<Scalars['String']['output']>;
    parentTypeName?: Maybe<Scalars['String']['output']>;
};
export type DirectiveUsageArgumentDefinitionAdded = {
    __typename?: 'DirectiveUsageArgumentDefinitionAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    argumentName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageArgumentDefinitionRemoved = {
    __typename?: 'DirectiveUsageArgumentDefinitionRemoved';
    argumentName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageArgumentRemoved = {
    __typename?: 'DirectiveUsageArgumentRemoved';
    directiveName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    parentArgumentName?: Maybe<Scalars['String']['output']>;
    parentEnumValueName?: Maybe<Scalars['String']['output']>;
    parentFieldName?: Maybe<Scalars['String']['output']>;
    parentTypeName?: Maybe<Scalars['String']['output']>;
    removedArgumentName: Scalars['String']['output'];
};
export type DirectiveUsageEnumAdded = {
    __typename?: 'DirectiveUsageEnumAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    enumName: Scalars['String']['output'];
};
export type DirectiveUsageEnumRemoved = {
    __typename?: 'DirectiveUsageEnumRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    enumName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageEnumValueAdded = {
    __typename?: 'DirectiveUsageEnumValueAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
};
export type DirectiveUsageEnumValueRemoved = {
    __typename?: 'DirectiveUsageEnumValueRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageFieldAdded = {
    __typename?: 'DirectiveUsageFieldAdded';
    addedDirectiveName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageFieldDefinitionAdded = {
    __typename?: 'DirectiveUsageFieldDefinitionAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageFieldDefinitionRemoved = {
    __typename?: 'DirectiveUsageFieldDefinitionRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageFieldRemoved = {
    __typename?: 'DirectiveUsageFieldRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    fieldName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type DirectiveUsageInputFieldDefinitionAdded = {
    __typename?: 'DirectiveUsageInputFieldDefinitionAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    inputFieldName: Scalars['String']['output'];
    inputFieldType: Scalars['String']['output'];
    inputObjectName: Scalars['String']['output'];
};
export type DirectiveUsageInputFieldDefinitionRemoved = {
    __typename?: 'DirectiveUsageInputFieldDefinitionRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    inputFieldName: Scalars['String']['output'];
    inputObjectName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageInputObjectAdded = {
    __typename?: 'DirectiveUsageInputObjectAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedInputFieldName: Scalars['String']['output'];
    addedInputFieldType: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    inputObjectName: Scalars['String']['output'];
    isAddedInputFieldTypeNullable?: Maybe<Scalars['Boolean']['output']>;
};
export type DirectiveUsageInputObjectRemoved = {
    __typename?: 'DirectiveUsageInputObjectRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    inputObjectName: Scalars['String']['output'];
    isRemovedInputFieldTypeNullable?: Maybe<Scalars['Boolean']['output']>;
    removedDirectiveName: Scalars['String']['output'];
    removedInputFieldName: Scalars['String']['output'];
    removedInputFieldType: Scalars['String']['output'];
};
export type DirectiveUsageInterfaceAdded = {
    __typename?: 'DirectiveUsageInterfaceAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    interfaceName: Scalars['String']['output'];
};
export type DirectiveUsageInterfaceRemoved = {
    __typename?: 'DirectiveUsageInterfaceRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    interfaceName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageObjectAdded = {
    __typename?: 'DirectiveUsageObjectAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    objectName: Scalars['String']['output'];
};
export type DirectiveUsageObjectRemoved = {
    __typename?: 'DirectiveUsageObjectRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    objectName: Scalars['String']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageScalarAdded = {
    __typename?: 'DirectiveUsageScalarAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
    scalarName: Scalars['String']['output'];
};
export type DirectiveUsageScalarRemoved = {
    __typename?: 'DirectiveUsageScalarRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    removedDirectiveName: Scalars['String']['output'];
    scalarName: Scalars['String']['output'];
};
export type DirectiveUsageSchemaAdded = {
    __typename?: 'DirectiveUsageSchemaAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    directiveRepeatedTimes: Scalars['Int']['output'];
};
export type DirectiveUsageSchemaRemoved = {
    __typename?: 'DirectiveUsageSchemaRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    removedDirectiveName: Scalars['String']['output'];
};
export type DirectiveUsageUnionMemberAdded = {
    __typename?: 'DirectiveUsageUnionMemberAdded';
    addedDirectiveName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    addedUnionMemberTypeName: Scalars['String']['output'];
    directiveRepeatedTimes: Scalars['Int']['output'];
    unionName: Scalars['String']['output'];
};
export type DirectiveUsageUnionMemberRemoved = {
    __typename?: 'DirectiveUsageUnionMemberRemoved';
    directiveRepeatedTimes: Scalars['Int']['output'];
    removedDirectiveName: Scalars['String']['output'];
    removedUnionMemberTypeName: Scalars['String']['output'];
    unionName: Scalars['String']['output'];
};
export type DisableContractInput = {
    contract: ContractReferenceInput;
};
export type DisableContractResult = {
    __typename?: 'DisableContractResult';
    error?: Maybe<DisableContractResultError>;
    ok?: Maybe<DisableContractResultOk>;
};
export type DisableContractResultError = {
    __typename?: 'DisableContractResultError';
    message: Scalars['String']['output'];
};
export type DisableContractResultOk = {
    __typename?: 'DisableContractResultOk';
    disabledContract: Contract;
};
export type DocumentCollection = {
    __typename?: 'DocumentCollection';
    createdAt: Scalars['DateTime']['output'];
    description?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    operations: DocumentCollectionOperationsConnection;
    updatedAt: Scalars['DateTime']['output'];
};
export type DocumentCollectionOperationsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type DocumentCollectionConnection = {
    __typename?: 'DocumentCollectionConnection';
    edges: Array<DocumentCollectionEdge>;
    pageInfo: PageInfo;
};
export type DocumentCollectionEdge = {
    __typename?: 'DocumentCollectionEdge';
    cursor: Scalars['String']['output'];
    node: DocumentCollection;
};
export type DocumentCollectionOperation = {
    __typename?: 'DocumentCollectionOperation';
    collection: DocumentCollection;
    createdAt: Scalars['DateTime']['output'];
    headers?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    query: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
    variables?: Maybe<Scalars['String']['output']>;
};
export type DocumentCollectionOperationEdge = {
    __typename?: 'DocumentCollectionOperationEdge';
    cursor: Scalars['String']['output'];
    node: DocumentCollectionOperation;
};
export type DocumentCollectionOperationsConnection = {
    __typename?: 'DocumentCollectionOperationsConnection';
    edges: Array<DocumentCollectionOperationEdge>;
    pageInfo: PageInfo;
};
export type DocumentInput = {
    /** GraphQL operation body. */
    body: Scalars['String']['input'];
    /** GraphQL operation hash. */
    hash: Scalars['String']['input'];
};
export type DowngradeToHobbyInput = {
    organization: OrganizationSelectorInput;
};
export type DurationInput = {
    max?: InputMaybe<Scalars['SafeInt']['input']>;
    min?: InputMaybe<Scalars['SafeInt']['input']>;
};
export type DurationOverTime = {
    __typename?: 'DurationOverTime';
    date: Scalars['DateTime']['output'];
    duration: DurationValues;
};
export type DurationValues = {
    __typename?: 'DurationValues';
    avg: Scalars['Int']['output'];
    p75: Scalars['Int']['output'];
    p90: Scalars['Int']['output'];
    p95: Scalars['Int']['output'];
    p99: Scalars['Int']['output'];
};
export type EnumValueAdded = {
    __typename?: 'EnumValueAdded';
    addedDirectiveDescription?: Maybe<Scalars['String']['output']>;
    addedEnumValueName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    enumName: Scalars['String']['output'];
};
export type EnumValueDeprecationReasonAdded = {
    __typename?: 'EnumValueDeprecationReasonAdded';
    addedValueDeprecationReason: Scalars['String']['output'];
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
};
export type EnumValueDeprecationReasonChanged = {
    __typename?: 'EnumValueDeprecationReasonChanged';
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
    newEnumValueDeprecationReason: Scalars['String']['output'];
    oldEnumValueDeprecationReason: Scalars['String']['output'];
};
export type EnumValueDeprecationReasonRemoved = {
    __typename?: 'EnumValueDeprecationReasonRemoved';
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
    removedEnumValueDeprecationReason: Scalars['String']['output'];
};
export type EnumValueDescriptionChanged = {
    __typename?: 'EnumValueDescriptionChanged';
    enumName: Scalars['String']['output'];
    enumValueName: Scalars['String']['output'];
    newEnumValueDescription?: Maybe<Scalars['String']['output']>;
    oldEnumValueDescription?: Maybe<Scalars['String']['output']>;
};
export type EnumValueRemoved = {
    __typename?: 'EnumValueRemoved';
    enumName: Scalars['String']['output'];
    isEnumValueDeprecated?: Maybe<Scalars['Boolean']['output']>;
    removedEnumValueName: Scalars['String']['output'];
};
export type Error = {
    message: Scalars['String']['output'];
};
export type Experimental__UpdateTargetSchemaCompositionInput = {
    nativeComposition: Scalars['Boolean']['input'];
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
};
export type ExportOrganizationAuditLogError = Error & {
    __typename?: 'ExportOrganizationAuditLogError';
    message: Scalars['String']['output'];
};
export type ExportOrganizationAuditLogInput = {
    filter: AuditLogFilter;
    selector: OrganizationSelectorInput;
};
export type ExportOrganizationAuditLogPayload = {
    __typename?: 'ExportOrganizationAuditLogPayload';
    url: Scalars['String']['output'];
};
export type ExportOrganizationAuditLogResult = {
    __typename?: 'ExportOrganizationAuditLogResult';
    error?: Maybe<ExportOrganizationAuditLogError>;
    ok?: Maybe<ExportOrganizationAuditLogPayload>;
};
export type ExternalSchemaComposition = {
    __typename?: 'ExternalSchemaComposition';
    endpoint: Scalars['String']['output'];
};
/** A failed schema check. */
export type FailedSchemaCheck = SchemaCheck & {
    __typename?: 'FailedSchemaCheck';
    breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
    /** Whether this schema check can be approved manually. */
    canBeApproved: Scalars['Boolean']['output'];
    /** Whether this schema check can be approved by the viewer. */
    canBeApprovedByViewer: Scalars['Boolean']['output'];
    compositeSchemaSDL?: Maybe<Scalars['String']['output']>;
    compositionErrors?: Maybe<SchemaErrorConnection>;
    /** Conditional breaking change metadata. */
    conditionalBreakingChangeMetadata?: Maybe<SchemaCheckConditionalBreakingChangeMetadata>;
    /** Optional context ID to group schema checks together. */
    contextId?: Maybe<Scalars['String']['output']>;
    /** Results of the contracts */
    contractChecks?: Maybe<ContractCheckConnection>;
    createdAt: Scalars['String']['output'];
    /** The GitHub repository associated with the schema check. */
    githubRepository?: Maybe<Scalars['String']['output']>;
    /** Whether this schema check has any schema 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>;
    schemaChanges?: Maybe<SchemaChangeConnection>;
    schemaPolicyErrors?: Maybe<SchemaPolicyWarningConnection>;
    schemaPolicyWarnings?: Maybe<SchemaPolicyWarningConnection>;
    /**
     * If the check is associated with a schema proposal, then this contains an unfiltered list of changes
     * to the SDL.
     */
    schemaProposalChanges?: Maybe<SchemaChangeConnection>;
    /** 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 FieldAdded = {
    __typename?: 'FieldAdded';
    addedFieldName: Scalars['String']['output'];
    addedFieldReturnType: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
    typeType: Scalars['String']['output'];
};
export type FieldArgumentAdded = {
    __typename?: 'FieldArgumentAdded';
    addedArgumentName: Scalars['String']['output'];
    addedArgumentType: Scalars['String']['output'];
    addedToNewField?: Maybe<Scalars['Boolean']['output']>;
    fieldName: Scalars['String']['output'];
    hasDefaultValue?: Maybe<Scalars['Boolean']['output']>;
    isAddedFieldArgumentBreaking?: Maybe<Scalars['Boolean']['output']>;
    typeName: Scalars['String']['output'];
};
export type FieldArgumentDefaultChanged = {
    __typename?: 'FieldArgumentDefaultChanged';
    argumentName: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    newDefaultValue?: Maybe<Scalars['String']['output']>;
    oldDefaultValue?: Maybe<Scalars['String']['output']>;
    typeName: Scalars['String']['output'];
};
export type FieldArgumentDescriptionChanged = {
    __typename?: 'FieldArgumentDescriptionChanged';
    argumentName: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    newDescription?: Maybe<Scalars['String']['output']>;
    oldDescription?: Maybe<Scalars['String']['output']>;
    typeName: Scalars['String']['output'];
};
export type FieldArgumentRemoved = {
    __typename?: 'FieldArgumentRemoved';
    fieldName: Scalars['String']['output'];
    removedFieldArgumentName: Scalars['String']['output'];
    removedFieldType: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldArgumentTypeChanged = {
    __typename?: 'FieldArgumentTypeChanged';
    argumentName: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    isSafeArgumentTypeChange?: Maybe<Scalars['Boolean']['output']>;
    newArgumentType: Scalars['String']['output'];
    oldArgumentType: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDeprecationAdded = {
    __typename?: 'FieldDeprecationAdded';
    deprecationReason: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDeprecationReasonAdded = {
    __typename?: 'FieldDeprecationReasonAdded';
    addedDeprecationReason: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDeprecationReasonChanged = {
    __typename?: 'FieldDeprecationReasonChanged';
    fieldName: Scalars['String']['output'];
    newDeprecationReason: Scalars['String']['output'];
    oldDeprecationReason: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDeprecationReasonRemoved = {
    __typename?: 'FieldDeprecationReasonRemoved';
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDeprecationRemoved = {
    __typename?: 'FieldDeprecationRemoved';
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDescriptionAdded = {
    __typename?: 'FieldDescriptionAdded';
    addedDescription: Scalars['String']['output'];
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldDescriptionChanged = {
    __typename?: 'FieldDescriptionChanged';
    fieldName: Scalars['String']['output'];
    newDescription?: Maybe<Scalars['String']['output']>;
    oldDescription?: Maybe<Scalars['String']['output']>;
    typeName: Scalars['String']['output'];
};
export type FieldDescriptionRemoved = {
    __typename?: 'FieldDescriptionRemoved';
    fieldName: Scalars['String']['output'];
    typeName: Scalars['String']['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 FieldRemoved = {
    __typename?: 'FieldRemoved';
    isRemovedFieldDeprecated?: Maybe<Scalars['Boolean']['output']>;
    removedFieldName: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
    typeType: Scalars['String']['output'];
};
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 FieldTypeChanged = {
    __typename?: 'FieldTypeChanged';
    fieldName: Scalars['String']['output'];
    isSafeFieldTypeChange?: Maybe<Scalars['Boolean']['output']>;
    newFieldType: Scalars['String']['output'];
    oldFieldType: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type FieldTypePairInput = {
    argument?: InputMaybe<Scalars['String']['input']>;
    field: Scalars['String']['input'];
    type: Scalars['String']['input'];
};
export type FilterBooleanOption = {
    __typename?: 'FilterBooleanOption';
    count: Scalars['Int']['output'];
    value: Scalars['Boolean']['output'];
};
export type FilterIntOption = {
    __typename?: 'FilterIntOption';
    count: Scalars['Int']['output'];
    value: Scalars['Int']['output'];
};
export type FilterStringOption = {
    __typename?: 'FilterStringOption';
    count: Scalars['Int']['output'];
    value: Scalars['String']['output'];
};
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 = GraphQlNamedType & {
    __typename?: 'GraphQLEnumType';
    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 = GraphQlNamedType & {
    __typename?: 'GraphQLInputObjectType';
    description?: Maybe<Scalars['String']['output']>;
    fields: Array<GraphQlInputField>;
    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>;
    usage: SchemaCoordinateUsage;
};
export type GraphQlInterfaceType = GraphQlNamedType & {
    __typename?: 'GraphQLInterfaceType';
    description?: Maybe<Scalars['String']['output']>;
    fields: Array<GraphQlField>;
    interfaces: Array<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;
};
export type GraphQlNamedType = {
    /** The description of the GraphQL type. */
    description?: Maybe<Scalars['String']['output']>;
    /** The name of the GraphQL type. */
    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>;
    /** The usage of the type within the specified period. */
    usage: SchemaCoordinateUsage;
};
export type GraphQlObjectType = GraphQlNamedType & {
    __typename?: 'GraphQLObjectType';
    description?: Maybe<Scalars['String']['output']>;
    fields: Array<GraphQlField>;
    interfaces: Array<Scalars['String']['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>;
    usage: SchemaCoordinateUsage;
};
export declare enum GraphQlOperationType {
    Mutation = "MUTATION",
    Query = "QUERY",
    Subscription = "SUBSCRIPTION"
}
export type GraphQlScalarType = GraphQlNamedType & {
    __typename?: 'GraphQLScalarType';
    description?: Maybe<Scalars['String']['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>;
    usage: SchemaCoordinateUsage;
};
export type GraphQlUnionType = GraphQlNamedType & {
    __typename?: 'GraphQLUnionType';
    description?: Maybe<Scalars['String']['output']>;
    members: Array<GraphQlUnionTypeMember>;
    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>;
    usage: SchemaCoordinateUsage;
};
export type GraphQlUnionTypeMember = {
    __typename?: 'GraphQLUnionTypeMember';
    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>;
    usage: SchemaCoordinateUsage;
};
export type InputFieldAdded = {
    __typename?: 'InputFieldAdded';
    addedFieldDefault?: Maybe<Scalars['String']['output']>;
    addedInputFieldName: Scalars['String']['output'];
    addedInputFieldType: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    inputName: Scalars['String']['output'];
    isAddedInputFieldTypeNullable?: Maybe<Scalars['Boolean']['output']>;
};
export type InputFieldDefaultValueChanged = {
    __typename?: 'InputFieldDefaultValueChanged';
    inputFieldName: Scalars['String']['output'];
    inputName: Scalars['String']['output'];
    newDefaultValue?: Maybe<Scalars['String']['output']>;
    oldDefaultValue?: Maybe<Scalars['String']['output']>;
};
export type InputFieldDescriptionAdded = {
    __typename?: 'InputFieldDescriptionAdded';
    addedInputFieldDescription: Scalars['String']['output'];
    inputFieldName: Scalars['String']['output'];
    inputName: Scalars['String']['output'];
};
export type InputFieldDescriptionChanged = {
    __typename?: 'InputFieldDescriptionChanged';
    inputFieldName: Scalars['String']['output'];
    inputName: Scalars['String']['output'];
    newInputFieldDescription: Scalars['String']['output'];
    oldInputFieldDescription: Scalars['String']['output'];
};
export type InputFieldDescriptionRemoved = {
    __typename?: 'InputFieldDescriptionRemoved';
    inputFieldName: Scalars['String']['output'];
    inputName: Scalars['String']['output'];
    removedDescription: Scalars['String']['output'];
};
export type InputFieldRemoved = {
    __typename?: 'InputFieldRemoved';
    inputName: Scalars['String']['output'];
    isInputFieldDeprecated?: Maybe<Scalars['Boolean']['output']>;
    removedFieldName: Scalars['String']['output'];
};
export type InputFieldTypeChanged = {
    __typename?: 'InputFieldTypeChanged';
    inputFieldName: Scalars['String']['output'];
    inputName: Scalars['String']['output'];
    isInputFieldTypeChangeSafe?: Maybe<Scalars['Boolean']['output']>;
    newInputFieldType: Scalars['String']['output'];
    oldInputFieldType: Scalars['String']['output'];
};
export type InsightsDateRange = {
    __typename?: 'InsightsDateRange';
    from: Scalars['String']['output'];
    to: Scalars['String']['output'];
};
export type InsightsDateRangeInput = {
    from: Scalars['String']['input'];
    to: Scalars['String']['input'];
};
export type InsightsFilterConfiguration = {
    __typename?: 'InsightsFilterConfiguration';
    clientFilters: Array<ClientFilter>;
    dateRange?: Maybe<InsightsDateRange>;
    excludeClientFilters?: Maybe<Scalars['Boolean']['output']>;
    excludeOperations?: Maybe<Scalars['Boolean']['output']>;
    operationHashes: Array<Scalars['String']['output']>;
};
export type InsightsFilterConfigurationInput = {
    clientFilters?: InputMaybe<Array<ClientFilterInput>>;
    dateRange?: InputMaybe<InsightsDateRangeInput>;
    excludeClientFilters?: InputMaybe<Scalars['Boolean']['input']>;
    excludeOperations?: InputMaybe<Scalars['Boolean']['input']>;
    operationHashes?: InputMaybe<Array<Scalars['String']['input']>>;
};
export type InviteToOrganizationByEmailInput = {
    email: Scalars['String']['input'];
    memberRoleId?: InputMaybe<Scalars['ID']['input']>;
    organization: OrganizationReferenceInput;
    resources?: InputMaybe<ResourceAssignmentInput>;
};
export type InviteToOrganizationByEmailInputErrors = {
    __typename?: 'InviteToOrganizationByEmailInputErrors';
    email?: Maybe<Scalars['String']['output']>;
};
/** @oneOf */
export type InviteToOrganizationByEmailResult = {
    __typename?: 'InviteToOrganizationByEmailResult';
    error?: Maybe<InviteToOrganizationByEmailResultError>;
    ok?: Maybe<InviteToOrganizationByEmailResultOk>;
};
export type InviteToOrganizationByEmailResultError = {
    __typename?: 'InviteToOrganizationByEmailResultError';
    /** The detailed validation error messages for the input fields. */
    inputErrors: InviteToOrganizationByEmailInputErrors;
    message: Scalars['String']['output'];
};
export type InviteToOrganizationByEmailResultOk = {
    __typename?: 'InviteToOrganizationByEmailResultOk';
    createdOrganizationInvitation: OrganizationInvitation;
};
export type JoinOrganizationPayload = OrganizationInvitationError | OrganizationPayload;
export type Lab = {
    __typename?: 'Lab';
    mocks?: Maybe<Scalars['JSON']['output']>;
    schema: Scalars['String']['output'];
};
export type LeaveOrganizationError = Error & {
    __typename?: 'LeaveOrganizationError';
    message: Scalars['String']['output'];
};
export type LeaveOrganizationOk = {
    __typename?: 'LeaveOrganizationOk';
    organizationId: Scalars['ID']['output'];
};
/** @oneOf */
export type LeaveOrganizationResult = {
    __typename?: 'LeaveOrganizationResult';
    error?: Maybe<LeaveOrganizationError>;
    ok?: Maybe<LeaveOrganizationOk>;
};
export type Member = {
    __typename?: 'Member';
    /** Access token for project. */
    accessToken?: Maybe<PersonalAccessToken>;
    /** Paginated list of access tokens issued for the project. */
    accessTokens: PersonalAccessTokenConnection;
    authProviders: Array<MemberAuthProvider>;
    availablePersonalAccessTokenPermissionGroups: Array<PermissionGroup>;
    canLeaveOrganization: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
    isOwner: Scalars['Boolean']['output'];
    resourceAssignment: ResourceAssignment;
    role: MemberRole;
    user: User;
    /** Whether the viewer can remove this member from the organization. */
    viewerCanRemove: Scalars['Boolean']['output'];
};
export type MemberAccessTokenArgs = {
    id: Scalars['ID']['input'];
    includeExpired?: InputMaybe<Scalars['Boolean']['input']>;
};
export type MemberAccessTokensArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    includeExpired?: InputMaybe<Scalars['Boolean']['input']>;
};
export type MemberAuthProvider = {
    __typename?: 'MemberAuthProvider';
    disabledReason?: Maybe<Scalars['String']['output']>;
    type: AuthProviderType;
};
export type MemberConnection = {
    __typename?: 'MemberConnection';
    edges: Array<MemberEdge>;
    pageInfo: PageInfo;
};
export type MemberEdge = {
    __typename?: 'MemberEdge';
    cursor: Scalars['String']['output'];
    node: Member;
};
export type MemberReferenceInput = {
    byId: Scalars['ID']['input'];
};
export type MemberRole = {
    __typename?: 'MemberRole';
    /** Whether the role can be deleted (based on current user's permissions) */
    canDelete: Scalars['Boolean']['output'];
    /** Whether the role can be used to invite new members (based on current user's permissions) */
    canInvite: Scalars['Boolean']['output'];
    /** Whether the role can be updated (based on current user's permissions) */
    canUpdate: Scalars['Boolean']['output'];
    description: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** Whether the role is a built-in role. Built-in roles cannot be deleted or modified. */
    isLocked: Scalars['Boolean']['output'];
    /** Amount of users within the organization that have this role assigned. */
    membersCount: Scalars['Int']['output'];
    name: Scalars['String']['output'];
    /** List of permissions attached to this member role. */
    permissions: Array<Scalars['String']['output']>;
};
export type MemberRoleConnection = {
    __typename?: 'MemberRoleConnection';
    edges: Array<MemberRoleEdge>;
    pageInfo: PageInfo;
};
export type MemberRoleEdge = {
    __typename?: 'MemberRoleEdge';
    cursor: Scalars['String']['output'];
    node: MemberRole;
};
export type MemberRoleReferenceInput = {
    byId: Scalars['ID']['input'];
};
export type MembersFilter = {
    /**
     * Part of a user's email or username that is used to filter the list of
     * members.
     */
    searchTerm?: InputMaybe<Scalars['String']['input']>;
};
export type MetadataAttribute = {
    __typename?: 'MetadataAttribute';
    name: Scalars['String']['output'];
    values: Array<Scalars['String']['output']>;
};
export type MetricAlertRule = {
    __typename?: 'MetricAlertRule';
    /** Destinations that receive notifications when this rule fires or resolves. */
    channels: Array<AlertChannel>;
    confirmationMinutes: Scalars['Int']['output'];
    createdAt: Scalars['DateTime']['output'];
    createdBy?: Maybe<User>;
    /** The currently open incident, if any. */
    currentIncident?: Maybe<MetricAlertRuleIncident>;
    direction: MetricAlertRuleDirection;
    enabled: Scalars['Boolean']['output'];
    /** Count of state transitions logged for this rule in the given time range. */
    eventCount: Scalars['Int']['output'];
    id: Scalars['ID']['output'];
    /** Past incidents for this alert rule, paginated newest-first. */
    incidents: MetricAlertRuleIncidentConnection;
    lastEvaluatedAt?: Maybe<Scalars['DateTime']['output']>;
    /** Most recent time this rule transitioned PENDING → FIRING (null if never fired). */
    lastTriggeredAt?: Maybe<Scalars['DateTime']['output']>;
    metric?: Maybe<MetricAlertRuleMetric>;
    name: Scalars['String']['output'];
    /** The saved filter that scopes this rule (null = applies to the whole target). */
    savedFilter?: Maybe<SavedFilter>;
    severity: MetricAlertRuleSeverity;
    state: MetricAlertRuleState;
    /**
     * State the rule was in at the given timestamp — the result of the most
     * recent transition before it (NORMAL if none). Seeds the leading edge of
     * the state timeline so a window with no transitions in it still reflects
     * the state the rule carried into the window.
     */
    stateAt: MetricAlertRuleState;
    /** State change history for this rule (powers the state timeline). */
    stateLog: Array<MetricAlertRuleStateChange>;
    thresholdType: MetricAlertRuleThresholdType;
    thresholdValue: Scalars['Float']['output'];
    timeWindowMinutes: Scalars['Int']['output'];
    type: MetricAlertRuleType;
    updatedAt: Scalars['DateTime']['output'];
    updatedBy?: Maybe<User>;
};
export type MetricAlertRuleEventCountArgs = {
    from: Scalars['DateTime']['input'];
    to: Scalars['DateTime']['input'];
};
export type MetricAlertRuleIncidentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type MetricAlertRuleStateAtArgs = {
    timestamp: Scalars['DateTime']['input'];
};
export type MetricAlertRuleStateLogArgs = {
    from: Scalars['DateTime']['input'];
    to: Scalars['DateTime']['input'];
};
export declare enum MetricAlertRuleDirection {
    Above = "ABOVE",
    Below = "BELOW"
}
export type MetricAlertRuleIncident = {
    __typename?: 'MetricAlertRuleIncident';
    currentValue: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    previousValue?: Maybe<Scalars['Float']['output']>;
    resolvedAt?: Maybe<Scalars['DateTime']['output']>;
    startedAt: Scalars['DateTime']['output'];
    /**
     * State-log entries that belong to this incident, oldest first. Includes the
     * PENDING→FIRING transition that opened it, any FIRING↔RECOVERING flapping,
     * and (for resolved incidents) the RECOVERING→NORMAL transition that closed
     * it. Entries are subject to plan-gated retention; rows that have aged out
     * are no longer returned.
     */
    stateLog: Array<MetricAlertRuleStateChange>;
    thresholdValue: Scalars['Float']['output'];
};
export type MetricAlertRuleIncidentConnection = {
    __typename?: 'MetricAlertRuleIncidentConnection';
    edges: Array<MetricAlertRuleIncidentEdge>;
    pageInfo: PageInfo;
};
export type MetricAlertRuleIncidentEdge = {
    __typename?: 'MetricAlertRuleIncidentEdge';
    cursor: Scalars['String']['output'];
    node: MetricAlertRuleIncident;
};
export declare enum MetricAlertRuleMetric {
    Avg = "AVG",
    P75 = "P75",
    P90 = "P90",
    P95 = "P95",
    P99 = "P99"
}
export declare enum MetricAlertRuleSeverity {
    Critical = "CRITICAL",
    Info = "INFO",
    Warning = "WARNING"
}
export declare enum MetricAlertRuleState {
    Firing = "FIRING",
    Normal = "NORMAL",
    Pending = "PENDING",
    Recovering = "RECOVERING"
}
export type MetricAlertRuleStateChange = {
    __typename?: 'MetricAlertRuleStateChange';
    createdAt: Scalars['DateTime']['output'];
    fromState: MetricAlertRuleState;
    id: Scalars['ID']['output'];
    /** Metric value in the previous (comparison) window at transition time. */
    previousValue?: Maybe<Scalars['Float']['output']>;
    /**
     * The rule that produced this transition. Nullable to tolerate the brief
     * race between fetching a state-log entry and resolving its rule when the
     * rule has been deleted (which cascade-deletes the state-log row itself).
     * Frontend list views filter entries with null rules at render time.
     */
    rule?: Maybe<MetricAlertRule>;
    /** Threshold value snapshotted at transition time (survives rule edits). */
    thresholdValue?: Maybe<Scalars['Float']['output']>;
    toState: MetricAlertRuleState;
    /** Metric value in the current window at transition time. */
    value?: Maybe<Scalars['Float']['output']>;
};
export declare enum MetricAlertRuleThresholdType {
    FixedValue = "FIXED_VALUE",
    PercentageChange = "PERCENTAGE_CHANGE"
}
export declare enum MetricAlertRuleType {
    ErrorRate = "ERROR_RATE",
    Latency = "LATENCY",
    Traffic = "TRAFFIC"
}
export type ModifyDocumentCollectionError = Error & {
    __typename?: 'ModifyDocumentCollectionError';
    message: Scalars['String']['output'];
};
export type ModifyDocumentCollectionOkPayload = {
    __typename?: 'ModifyDocumentCollectionOkPayload';
    collection: DocumentCollection;
    updatedTarget: Target;
};
export type ModifyDocumentCollectionOperationOkPayload = {
    __typename?: 'ModifyDocumentCollectionOperationOkPayload';
    collection: DocumentCollection;
    operation: DocumentCollectionOperation;
    updatedTarget: Target;
};
/** @oneOf */
export type ModifyDocumentCollectionOperationResult = {
    __typename?: 'ModifyDocumentCollectionOperationResult';
    error?: Maybe<ModifyDocumentCollectionError>;
    ok?: Maybe<ModifyDocumentCollectionOperationOkPayload>;
};
/** @oneOf */
export type ModifyDocumentCollectionResult = {
    __typename?: 'ModifyDocumentCollectionResult';
    error?: Maybe<ModifyDocumentCollectionError>;
    ok?: Maybe<ModifyDocumentCollectionOkPayload>;
};
export type MonthlyUsage = {
    __typename?: 'MonthlyUsage';
    /** Start of the month in 1992-10-21 format */
    date: Scalars['Date']['output'];
    total: Scalars['SafeInt']['output'];
};
export type Mutation = {
    __typename?: 'Mutation';
    activateAppDeployment: ActivateAppDeploymentResult;
    addAlert: AddAlertResult;
    addAlertChannel: AddAlertChannelResult;
    addDocumentsToAppDeployment: AddDocumentsToAppDeploymentResult;
    addGitHubIntegration: Scalars['Boolean']['output'];
    addMetricAlertRule: AddMetricAlertRuleResult;
    addSlackIntegration: Scalars['Boolean']['output'];
    answerOrganizationTransferRequest: AnswerOrganizationTransferRequestResult;
    /** Approve a failed schema check with breaking changes. */
    approveFailedSchemaCheck: ApproveFailedSchemaCheckResult;
    assignMemberRole: AssignMemberRoleResult;
    createAppDeployment: CreateAppDeploymentResult;
    /** Create a CDN access token for a target. */
    createCdnAccessToken: CdnAccessTokenCreateResult;
    /** Create a contract for a given target. */
    createContract: CreateContractResult;
    createDocumentCollection: ModifyDocumentCollectionResult;
    /** Create a new member role with permissions. */
    createMemberRole: CreateMemberRoleResult;
    createOIDCIntegration: CreateOidcIntegrationResult;
    createOperationInDocumentCollection: ModifyDocumentCollectionOperationResult;
    createOrganization: CreateOrganizationResult;
    /** Create a new access token scoped to an organization. */
    createOrganizationAccessToken: CreateOrganizationAccessTokenResult;
    /** Create a new personal access token for the current actor/user. */
    createPersonalAccessToken: CreatePersonalAccessTokenResult;
    createProject: CreateProjectResult;
    /** Create a new access token scoped to a project. */
    createProjectAccessToken: CreateProjectAccessTokenResult;
    createSavedFilter: CreateSavedFilterResult;
    createSchemaProposal: CreateSchemaProposalResult;
    /** Create a new target within an existing project. */
    createTarget: CreateTargetResult;
    createToken: CreateTokenResult;
    /** Delete any type of access token (organization, project, or personal). */
    deleteAccessToken: DeleteAccessTokenResult;
    deleteAlertChannels: DeleteAlertChannelsResult;
    deleteAlerts: DeleteAlertsResult;
    /** Delete a CDN access token. */
    deleteCdnAccessToken: DeleteCdnAccessTokenResult;
    deleteDocumentCollection: DeleteDocumentCollectionResult;
    deleteGitHubIntegration: DeleteGitHubIntegrationResult;
    deleteMemberRole: DeleteMemberRoleResult;
    deleteMetricAlertRules: DeleteMetricAlertRulesResult;
    /** Remove a domain from the OIDC provider list. */
    deleteOIDCDomain: DeleteOidcDomainResult;
    deleteOIDCIntegration: DeleteOidcIntegrationResult;
    deleteOperationInDocumentCollection: DeleteDocumentCollectionOperationResult;
    deleteOrganization: OrganizationPayload;
    /**
     * Delete an organization-level access token.
     * @deprecated Please use 'Mutation.deleteAccessToken' instead.
     */
    deleteOrganizationAccessToken: DeleteOrganizationAccessTokenResult;
    deleteOrganizationInvitation: DeleteOrganizationInvitationResult;
    deleteOrganizationMember: OrganizationPayload;
    deleteProject: DeleteProjectResult;
    deleteSavedFilter: DeleteSavedFilterResult;
    deleteSlackIntegration: DeleteSlackIntegrationResult;
    /** Delete a target. */
    deleteTarget: DeleteTargetResult;
    deleteTokens: DeleteTokensPayload;
    /** Disable a contract. */
    disableContract: DisableContractResult;
    downgradeToHobby: ChangePlanResult;
    enableProjectNameInGithubCheck: Project;
    /**
     * Overwrites project's schema composition library.
     * Works only for Federation projects with native composition enabled.
     * This mutation is temporary and will be removed once no longer needed.
     * It's part of a feature flag called "forceLegacyCompositionInTargets".
     */
    experimental__updateTargetSchemaComposition: Target;
    exportOrganizationAuditLog: ExportOrganizationAuditLogResult;
    generateStripePortalLink: Scalars['String']['output'];
    inviteToOrganizationByEmail: InviteToOrganizationByEmailResult;
    joinOrganization: JoinOrganizationPayload;
    leaveOrganization: LeaveOrganizationResult;
    /** Register a domain for the OIDC provider for a verification challenge. */
    registerOIDCDomain: RegisterOidcDomainResult;
    replyToSchemaProposalReview: ReplyToSchemaProposalReviewResult;
    /** Request a new domain verification challenge */
    requestOIDCDomainChallenge: RequestOidcDomainChallengeResult;
    requestOrganizationTransfer: RequestOrganizationTransferResult;
    retireAppDeployment: RetireAppDeploymentResult;
    reviewSchemaProposal: ReviewSchemaProposalResult;
    schemaCheck: SchemaCheckPayload;
    schemaCompose: SchemaComposePayload;
    schemaDelete: SchemaDeleteResult;
    schemaPublish: SchemaPublishPayload;
    /**
     * Promote a schema version within a project to a graph.
     * e.g. for rollbacks within a target or multi-stage environment deployments cross targets.
     */
    schemaVersionPromote: SchemaVersionPromoteResult;
    sendVerificationEmail: SendVerificationEmailResult;
    supportTicketCreate: SupportTicketCreateResult;
    supportTicketReply: SupportTicketReplyResult;
    trackSavedFilterView: TrackSavedFilterViewResult;
    updateBaseSchema: UpdateBaseSchemaResult;
    updateDocumentCollection: ModifyDocumentCollectionResult;
    updateMe: UpdateMeResult;
    updateMemberRole: UpdateMemberRoleResult;
    updateMetricAlertRule: UpdateMetricAlertRuleResult;
    updateOIDCDefaultMemberRole: UpdateOidcDefaultMemberRoleResult;
    updateOIDCDefaultResourceAssignment: UpdateOidcDefaultResourceAssignmentResult;
    updateOIDCIntegration: UpdateOidcIntegrationResult;
    updateOIDCRestrictions: UpdateOidcRestrictionsResult;
    updateOperationInDocumentCollection: ModifyDocumentCollectionOperationResult;
    updateOrgRateLimit: Organization;
    updateOrganizationSlug: UpdateOrganizationSlugResult;
    updatePreflightScript: PreflightScriptResult;
    updateProjectSlug: UpdateProjectSlugResult;
    updateSavedFilter: UpdateSavedFilterResult;
    /** Update the schema composition configuration of a federation project. */
    updateSchemaComposition: UpdateSchemaCompositionResult;
    updateSchemaPolicyForOrganization: UpdateSchemaPolicyResult;
    updateSchemaPolicyForProject: UpdateSchemaPolicyResult;
    /** Update the app deployment protection configuration of a target. */
    updateTargetAppDeploymentProtectionConfiguration: UpdateTargetAppDeploymentProtectionConfigurationResult;
    /** Update the conditional breaking change configuration of a target. */
    updateTargetConditionalBreakingChangeConfiguration: UpdateTargetConditionalBreakingChangeConfigurationResult;
    /**
     * Update the targets dangerous change classification settings.
     * This allows dangerous changes fail schema checks.
     */
    updateTargetDangerousChangeClassification: UpdateTargetDangerousChangeClassificationResult;
    /** Updates the target's explorer endpoint url. */
    updateTargetGraphQLEndpointUrl: UpdateTargetGraphQlEndpointUrlResult;
    /** Update the slug of a traget. */
    updateTargetSlug: UpdateTargetSlugResult;
    upgradeToPro: ChangePlanResult;
    verifyEmail: VerifyEmailResult;
    /** Verify the domain verification challenge */
    verifyOIDCDomainChallenge: VerifyOidcDomainChallengeResult;
};
export type MutationActivateAppDeploymentArgs = {
    input: ActivateAppDeploymentInput;
};
export type MutationAddAlertArgs = {
    input: AddAlertInput;
};
export type MutationAddAlertChannelArgs = {
    input: AddAlertChannelInput;
};
export type MutationAddDocumentsToAppDeploymentArgs = {
    input: AddDocumentsToAppDeploymentInput;
};
export type MutationAddGitHubIntegrationArgs = {
    input: AddGitHubIntegrationInput;
};
export type MutationAddMetricAlertRuleArgs = {
    input: AddMetricAlertRuleInput;
};
export type MutationAddSlackIntegrationArgs = {
    input: AddSlackIntegrationInput;
};
export type MutationAnswerOrganizationTransferRequestArgs = {
    input: AnswerOrganizationTransferRequestInput;
};
export type MutationApproveFailedSchemaCheckArgs = {
    input: ApproveFailedSchemaCheckInput;
};
export type MutationAssignMemberRoleArgs = {
    input: AssignMemberRoleInput;
};
export type MutationCreateAppDeploymentArgs = {
    input: CreateAppDeploymentInput;
};
export type MutationCreateCdnAccessTokenArgs = {
    input: CreateCdnAccessTokenInput;
};
export type MutationCreateContractArgs = {
    input: CreateContractInput;
};
export type MutationCreateDocumentCollectionArgs = {
    input: CreateDocumentCollectionInput;
    selector: TargetSelectorInput;
};
export type MutationCreateMemberRoleArgs = {
    input: CreateMemberRoleInput;
};
export type MutationCreateOidcIntegrationArgs = {
    input: CreateOidcIntegrationInput;
};
export type MutationCreateOperationInDocumentCollectionArgs = {
    input: CreateDocumentCollectionOperationInput;
    selector: TargetSelectorInput;
};
export type MutationCreateOrganizationArgs = {
    input: CreateOrganizationInput;
};
export type MutationCreateOrganizationAccessTokenArgs = {
    input: CreateOrganizationAccessTokenInput;
};
export type MutationCreatePersonalAccessTokenArgs = {
    input: CreatePersonalAccessTokenInput;
};
export type MutationCreateProjectArgs = {
    input: CreateProjectInput;
};
export type MutationCreateProjectAccessTokenArgs = {
    input: CreateProjectAccessTokenInput;
};
export type MutationCreateSavedFilterArgs = {
    input: CreateSavedFilterInput;
};
export type MutationCreateSchemaProposalArgs = {
    input: CreateSchemaProposalInput;
};
export type MutationCreateTargetArgs = {
    input: CreateTargetInput;
};
export type MutationCreateTokenArgs = {
    input: CreateTokenInput;
};
export type MutationDeleteAccessTokenArgs = {
    input: DeleteAccessTokenInput;
};
export type MutationDeleteAlertChannelsArgs = {
    input: DeleteAlertChannelsInput;
};
export type MutationDeleteAlertsArgs = {
    input: DeleteAlertsInput;
};
export type MutationDeleteCdnAccessTokenArgs = {
    input: DeleteCdnAccessTokenInput;
};
export type MutationDeleteDocumentCollectionArgs = {
    id: Scalars['ID']['input'];
    selector: TargetSelectorInput;
};
export type MutationDeleteGitHubIntegrationArgs = {
    input: OrganizationSelectorInput;
};
export type MutationDeleteMemberRoleArgs = {
    input: DeleteMemberRoleInput;
};
export type MutationDeleteMetricAlertRulesArgs = {
    input: DeleteMetricAlertRulesInput;
};
export type MutationDeleteOidcDomainArgs = {
    input: DeleteOidcDomainInput;
};
export type MutationDeleteOidcIntegrationArgs = {
    input: DeleteOidcIntegrationInput;
};
export type MutationDeleteOperationInDocumentCollectionArgs = {
    id: Scalars['ID']['input'];
    selector: TargetSelectorInput;
};
export type MutationDeleteOrganizationArgs = {
    selector: OrganizationSelectorInput;
};
export type MutationDeleteOrganizationAccessTokenArgs = {
    input: DeleteOrganizationAccessTokenInput;
};
export type MutationDeleteOrganizationInvitationArgs = {
    input: DeleteOrganizationInvitationInput;
};
export type MutationDeleteOrganizationMemberArgs = {
    input: OrganizationMemberInput;
};
export type MutationDeleteProjectArgs = {
    input: DeleteProjectInput;
};
export type MutationDeleteSavedFilterArgs = {
    input: DeleteSavedFilterInput;
};
export type MutationDeleteSlackIntegrationArgs = {
    input: OrganizationSelectorInput;
};
export type MutationDeleteTargetArgs = {
    input: DeleteTargetInput;
};
export type MutationDeleteTokensArgs = {
    input: DeleteTokensInput;
};
export type MutationDisableContractArgs = {
    input: DisableContractInput;
};
export type MutationDowngradeToHobbyArgs = {
    input: DowngradeToHobbyInput;
};
export type MutationEnableProjectNameInGithubCheckArgs = {
    input: ProjectSelectorInput;
};
export type MutationExperimental__UpdateTargetSchemaCompositionArgs = {
    input: Experimental__UpdateTargetSchemaCompositionInput;
};
export type MutationExportOrganizationAuditLogArgs = {
    input: ExportOrganizationAuditLogInput;
};
export type MutationGenerateStripePortalLinkArgs = {
    selector: OrganizationSelectorInput;
};
export type MutationInviteToOrganizationByEmailArgs = {
    input: InviteToOrganizationByEmailInput;
};
export type MutationJoinOrganizationArgs = {
    code: Scalars['String']['input'];
};
export type MutationLeaveOrganizationArgs = {
    input: OrganizationSelectorInput;
};
export type MutationRegisterOidcDomainArgs = {
    input: RegisterOidcDomainInput;
};
export type MutationReplyToSchemaProposalReviewArgs = {
    input: ReplyToSchemaProposalReviewInput;
};
export type MutationRequestOidcDomainChallengeArgs = {
    input: RequestOidcDomainChallengeInput;
};
export type MutationRequestOrganizationTransferArgs = {
    input: RequestOrganizationTransferInput;
};
export type MutationRetireAppDeploymentArgs = {
    input: RetireAppDeploymentInput;
};
export type MutationReviewSchemaProposalArgs = {
    input: ReviewSchemaProposalInput;
};
export type MutationSchemaCheckArgs = {
    input: SchemaCheckInput;
};
export type MutationSchemaComposeArgs = {
    input: SchemaComposeInput;
};
export type MutationSchemaDeleteArgs = {
    input: SchemaDeleteInput;
};
export type MutationSchemaPublishArgs = {
    input: SchemaPublishInput;
};
export type MutationSchemaVersionPromoteArgs = {
    input: SchemaVersionPromoteInput;
};
export type MutationSendVerificationEmailArgs = {
    input: SendVerificationEmailInput;
};
export type MutationSupportTicketCreateArgs = {
    input: SupportTicketCreateInput;
};
export type MutationSupportTicketReplyArgs = {
    input: SupportTicketReplyInput;
};
export type MutationTrackSavedFilterViewArgs = {
    input: TrackSavedFilterViewInput;
};
export type MutationUpdateBaseSchemaArgs = {
    input: UpdateBaseSchemaInput;
};
export type MutationUpdateDocumentCollectionArgs = {
    input: UpdateDocumentCollectionInput;
    selector: TargetSelectorInput;
};
export type MutationUpdateMeArgs = {
    input: UpdateMeInput;
};
export type MutationUpdateMemberRoleArgs = {
    input: UpdateMemberRoleInput;
};
export type MutationUpdateMetricAlertRuleArgs = {
    input: UpdateMetricAlertRuleInput;
};
export type MutationUpdateOidcDefaultMemberRoleArgs = {
    input: UpdateOidcDefaultMemberRoleInput;
};
export type MutationUpdateOidcDefaultResourceAssignmentArgs = {
    input: UpdateOidcDefaultResourceAssignmentInput;
};
export type MutationUpdateOidcIntegrationArgs = {
    input: UpdateOidcIntegrationInput;
};
export type MutationUpdateOidcRestrictionsArgs = {
    input: UpdateOidcRestrictionsInput;
};
export type MutationUpdateOperationInDocumentCollectionArgs = {
    input: UpdateDocumentCollectionOperationInput;
    selector: TargetSelectorInput;
};
export type MutationUpdateOrgRateLimitArgs = {
    monthlyLimits: RateLimitInput;
    selector: OrganizationSelectorInput;
};
export type MutationUpdateOrganizationSlugArgs = {
    input: UpdateOrganizationSlugInput;
};
export type MutationUpdatePreflightScriptArgs = {
    input: UpdatePreflightScriptInput;
};
export type MutationUpdateProjectSlugArgs = {
    input: UpdateProjectSlugInput;
};
export type MutationUpdateSavedFilterArgs = {
    input: UpdateSavedFilterInput;
};
export type MutationUpdateSchemaCompositionArgs = {
    input: UpdateSchemaCompositionInput;
};
export type MutationUpdateSchemaPolicyForOrganizationArgs = {
    allowOverrides: Scalars['Boolean']['input'];
    policy: SchemaPolicyInput;
    selector: OrganizationSelectorInput;
};
export type MutationUpdateSchemaPolicyForProjectArgs = {
    policy: SchemaPolicyInput;
    selector: ProjectSelectorInput;
};
export type MutationUpdateTargetAppDeploymentProtectionConfigurationArgs = {
    input: UpdateTargetAppDeploymentProtectionConfigurationInput;
};
export type MutationUpdateTargetConditionalBreakingChangeConfigurationArgs = {
    input: UpdateTargetConditionalBreakingChangeConfigurationInput;
};
export type MutationUpdateTargetDangerousChangeClassificationArgs = {
    input: UpdateTargetDangerousChangeClassificationInput;
};
export type MutationUpdateTargetGraphQlEndpointUrlArgs = {
    input: UpdateTargetGraphQlEndpointUrlInput;
};
export type MutationUpdateTargetSlugArgs = {
    input: UpdateTargetSlugInput;
};
export type MutationUpgradeToProArgs = {
    input: UpgradeToProInput;
};
export type MutationVerifyEmailArgs = {
    input: VerifyEmailInput;
};
export type MutationVerifyOidcDomainChallengeArgs = {
    input: VerifyOidcDomainChallengeInput;
};
export type NativeCompositionCompatibility = {
    __typename?: 'NativeCompositionCompatibility';
    results: Array<Maybe<NativeCompositionVersionStatus>>;
    /** Whether the schema version is compatible. */
    status: NativeFederationCompatibilityStatusType;
};
export type NativeCompositionVersionStatus = {
    __typename?: 'NativeCompositionVersionStatus';
    /** The supergraph of the latest valid schema version (sorted and normalized). */
    currentSupergraphSdl: Scalars['String']['output'];
    /** The native composition result. The supergraphSdl is sorted and normalized. */
    nativeCompositionResult: SchemaCompositionResult;
    /** The schema version we check against. */
    schemaVersion: SchemaVersion;
};
export declare enum NativeFederationCompatibilityStatusType {
    Compatible = "COMPATIBLE",
    Incompatible = "INCOMPATIBLE",
    NotApplicable = "NOT_APPLICABLE",
    Unknown = "UNKNOWN"
}
export type OidcIntegration = {
    __typename?: 'OIDCIntegration';
    additionalScopes: Array<Scalars['String']['output']>;
    authorizationEndpoint: Scalars['String']['output'];
    clientId: Scalars['ID']['output'];
    clientSecretPreview: Scalars['String']['output'];
    defaultMemberRole: MemberRole;
    defaultResourceAssignment?: Maybe<ResourceAssignment>;
    id: Scalars['ID']['output'];
    oidcUserAccessOnly: Scalars['Boolean']['output'];
    oidcUserJoinOnly: Scalars['Boolean']['output'];
    /** List of domains registered with this OIDC integration. */
    registeredDomains: Array<OidcIntegrationDomain>;
    requireInvitation: Scalars['Boolean']['output'];
    tokenEndpoint: Scalars['String']['output'];
    userinfoEndpoint: Scalars['String']['output'];
};
export type OidcIntegrationDomain = {
    __typename?: 'OIDCIntegrationDomain';
    challenge?: Maybe<OidcIntegrationDomainChallenge>;
    createdAt: Scalars['DateTime']['output'];
    domainName: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    verifiedAt?: Maybe<Scalars['DateTime']['output']>;
};
export type OidcIntegrationDomainChallenge = {
    __typename?: 'OIDCIntegrationDomainChallenge';
    recordName: Scalars['String']['output'];
    recordType: Scalars['String']['output'];
    recordValue: Scalars['String']['output'];
};
export type OidcIntegrationLogEvent = {
    __typename?: 'OIDCIntegrationLogEvent';
    message: Scalars['String']['output'];
    timestamp: Scalars['DateTime']['output'];
};
export type OidcIntegrationLogSubscriptionInput = {
    oidcIntegrationId: Scalars['ID']['input'];
};
export type ObjectTypeInterfaceAdded = {
    __typename?: 'ObjectTypeInterfaceAdded';
    addedInterfaceName: Scalars['String']['output'];
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    objectTypeName: Scalars['String']['output'];
};
export type ObjectTypeInterfaceRemoved = {
    __typename?: 'ObjectTypeInterfaceRemoved';
    objectTypeName: Scalars['String']['output'];
    removedInterfaceName: Scalars['String']['output'];
};
export type Operation = {
    __typename?: 'Operation';
    /** Operation body */
    body: Scalars['String']['output'];
    /** Hash that uniquely identifies the operation. */
    hash: Scalars['ID']['output'];
    /** Name of the operation */
    name?: Maybe<Scalars['String']['output']>;
    /** Operation type */
    type: GraphQlOperationType;
};
export type OperationStatsFilterInput = {
    /**
     * Filter by only showing operations performed by specific clients.
     * @deprecated Use 'clientVersionFilters' instead for more precise filtering by client name and version.
     */
    clientNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /**
     * Filter by specific client name + version combinations.
     * More precise than clientNames - allows filtering to specific versions.
     */
    clientVersionFilters?: InputMaybe<Array<ClientVersionFilterInput>>;
    /** When true, the clientVersionFilters filter is negated — matching clients are excluded instead of included. */
    excludeClientVersionFilters?: InputMaybe<Scalars['Boolean']['input']>;
    /** When true, the operationIds filter is negated — matching operations are excluded instead of included. */
    excludeOperations?: InputMaybe<Scalars['Boolean']['input']>;
    /** Filter by only showing operations with a specific id. */
    operationIds?: InputMaybe<Array<Scalars['ID']['input']>>;
};
export type OperationStatsValues = {
    __typename?: 'OperationStatsValues';
    /** Total number of requests */
    count: Scalars['SafeInt']['output'];
    /** Number of requests that succeeded */
    countOk: Scalars['SafeInt']['output'];
    duration: DurationValues;
    id: Scalars['ID']['output'];
    kind: Scalars['String']['output'];
    name: Scalars['String']['output'];
    operationHash: Scalars['String']['output'];
    percentage: Scalars['Float']['output'];
};
export type OperationStatsValuesConnection = {
    __typename?: 'OperationStatsValuesConnection';
    edges: Array<OperationStatsValuesEdge>;
    pageInfo: PageInfo;
};
export type OperationStatsValuesEdge = {
    __typename?: 'OperationStatsValuesEdge';
    cursor: Scalars['String']['output'];
    node: OperationStatsValues;
};
export type OperationsStats = {
    __typename?: 'OperationsStats';
    clients: ClientStatsValuesConnection;
    duration: DurationValues;
    durationOverTime: Array<DurationOverTime>;
    failuresOverTime: Array<FailuresOverTime>;
    operations: OperationStatsValuesConnection;
    requestsOverTime: Array<RequestsOverTime>;
    totalFailures: Scalars['SafeInt']['output'];
    totalOperations: Scalars['Int']['output'];
    totalRequests: Scalars['SafeInt']['output'];
};
export type OperationsStatsDurationOverTimeArgs = {
    resolution: Scalars['Int']['input'];
};
export type OperationsStatsFailuresOverTimeArgs = {
    resolution: Scalars['Int']['input'];
};
export type OperationsStatsRequestsOverTimeArgs = {
    resolution: Scalars['Int']['input'];
};
export type Organization = {
    __typename?: 'Organization';
    /** Retrieve a organization scoped access token by it's id. */
    accessToken?: Maybe<OrganizationAccessToken>;
    /** Retrieve an access token within the organization by its ID. */
    accessTokenById?: Maybe<AccessToken>;
    /** Paginated list of all organization scoped access tokens. */
    accessTokens: OrganizationAccessTokenConnection;
    /**
     * Retrieve a list of all access tokens within the organization.
     * This includes organization, project and personal scoped access tokens.
     */
    allAccessTokens: AccessTokenConnection;
    /** List of available permission groups that can be assigned to users. */
    availableMemberPermissionGroups: Array<PermissionGroup>;
    /** List of available permission groups that can be assigned to organization access tokens. */
    availableOrganizationAccessTokenPermissionGroups: Array<PermissionGroup>;
    billingConfiguration: BillingConfiguration;
    /** @deprecated Use the 'slug' field instead. */
    cleanId: Scalars['ID']['output'];
    getStarted: OrganizationGetStarted;
    gitHubIntegration?: Maybe<GitHubIntegration>;
    hasGitHubIntegration: Scalars['Boolean']['output'];
    hasSlackIntegration: Scalars['Boolean']['output'];
    /** Unique UUID of the organization */
    id: Scalars['ID']['output'];
    invitations?: Maybe<OrganizationInvitationConnection>;
    isAppDeploymentsEnabled: Scalars['Boolean']['output'];
    /**
     * Whether or not the monthly operations limit is currently exceeded.
     * For hobby and pro plans, once the limit is exceeded, operation usage data received from the organization will be ignored.
     * Enterprise plans will continue to have their usage data ingested.
     */
    isMonthlyOperationsLimitExceeded: Scalars['Boolean']['output'];
    /** Returns 'null' if the user is not a member of the organization, but able to see the organization (admin user). */
    me?: Maybe<Member>;
    memberRoles?: Maybe<MemberRoleConnection>;
    members: MemberConnection;
    /**
     * The monthly limit for number of operations ingested.
     * For hobby and pro plans, once this limit is exceeded, operation usage data received from the organization will be ignored.
     * Enterprise plans will continue to have their usage data ingested.
     */
    monthlyOperationsLimit: Scalars['SafeInt']['output'];
    /** @deprecated Use the 'slug' field instead. */
    name: Scalars['String']['output'];
    oidcIntegration?: Maybe<OidcIntegration>;
    owner: Member;
    plan: BillingPlanType;
    projectBySlug?: Maybe<Project>;
    /**
     * Retrieves a single project and its associated targets for resource selection
     * by its unique identifier.
     *
     * The result can be filtered by intent to adjust access based on context.
     */
    projectForResourceSelector?: Maybe<ProjectForResourceSelector>;
    projects: ProjectConnection;
    /**
     * Retrieves a list of all projects and their targets available for resource selection
     * within the organization.
     *
     * The result can be filtered by intent, which defines the context of selection
     * (e.g., administrative vs. user-level operations).
     */
    projectsForResourceSelector: Array<ProjectForResourceSelector>;
    /** @deprecated All subfields moved to Organization */
    rateLimit: RateLimit;
    schemaPolicy?: Maybe<SchemaPolicy>;
    /** The slug of the organization. */
    slug: Scalars['String']['output'];
    supportTicket?: Maybe<SupportTicket>;
    supportTickets?: Maybe<SupportTicketConnection>;
    /**
     * An approximation of the current monthly operation usage. This is based on how many operations have
     * been successfully ingested by Hive, which is an asynchronous process.
     */
    usageEstimation?: Maybe<UsageEstimation>;
    /** The configured retention for usage information, in days. Retention impacts how long data is stored. */
    usageRetentionInDays: Scalars['Int']['output'];
    /** Whether the viewer should be able to access the settings page within the app */
    viewerCanAccessSettings: Scalars['Boolean']['output'];
    /** Whether the viewer can assign roles to users */
    viewerCanAssignUserRoles: Scalars['Boolean']['output'];
    viewerCanCreateProject: Scalars['Boolean']['output'];
    /** Whether the viewer can delete the organization */
    viewerCanDelete: Scalars['Boolean']['output'];
    viewerCanDescribeBilling: Scalars['Boolean']['output'];
    /** The organization's audit logs. This field is only available to members with the Admin role. */
    viewerCanExportAuditLogs: Scalars['Boolean']['output'];
    /** Whether the viewer can manage access tokens. */
    viewerCanManageAccessTokens: Scalars['Boolean']['output'];
    /** Whether the viewer can manage member invites */
    viewerCanManageInvitations: Scalars['Boolean']['output'];
    viewerCanManageOIDCIntegration: Scalars['Boolean']['output'];
    /** Whether the viewer can manage personal access tokens. */
    viewerCanManagePersonalAccessTokens: Scalars['Boolean']['output'];
    /** Whether the viewer can modify roles of members within the organization */
    viewerCanManageRoles: Scalars['Boolean']['output'];
    viewerCanManageSupportTickets: Scalars['Boolean']['output'];
    viewerCanModifyBilling: Scalars['Boolean']['output'];
    viewerCanModifyGitHubIntegration: Scalars['Boolean']['output'];
    /** Whether the viewer can view and modify the schema policy for this organization */
    viewerCanModifySchemaPolicy: Scalars['Boolean']['output'];
    viewerCanModifySlackIntegration: Scalars['Boolean']['output'];
    /** Whether the viewer can modify the organization slug */
    viewerCanModifySlug: Scalars['Boolean']['output'];
    /** Whether the viewer can see the members within the organization */
    viewerCanSeeMembers: Scalars['Boolean']['output'];
    /** Whether the viewer can transfer ownership of the organization */
    viewerCanTransferOwnership: Scalars['Boolean']['output'];
};
export type OrganizationAccessTokenArgs = {
    id: Scalars['ID']['input'];
};
export type OrganizationAccessTokenByIdArgs = {
    id: Scalars['ID']['input'];
};
export type OrganizationAccessTokensArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationAllAccessTokensArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationInvitationsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationMemberRolesArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationMembersArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filters?: InputMaybe<MembersFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationProjectBySlugArgs = {
    projectSlug: Scalars['String']['input'];
};
export type OrganizationProjectForResourceSelectorArgs = {
    intent: ResourceSelectorIntentType;
    projectId: Scalars['ID']['input'];
};
export type OrganizationProjectsForResourceSelectorArgs = {
    intent: ResourceSelectorIntentType;
};
export type OrganizationSupportTicketArgs = {
    id: Scalars['ID']['input'];
};
export type OrganizationSupportTicketsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type OrganizationUsageEstimationArgs = {
    input: OrganizationUsageEstimationInput;
};
export declare enum OrganizationAccessScope {
    Delete = "DELETE",
    Integrations = "INTEGRATIONS",
    Members = "MEMBERS",
    Read = "READ",
    Settings = "SETTINGS"
}
/** Organization-scoped access token. */
export type OrganizationAccessToken = AccessToken & {
    __typename?: 'OrganizationAccessToken';
    createdAt: Scalars['DateTime']['output'];
    description?: Maybe<Scalars['String']['output']>;
    /** If set, then this is when the token will expire and become invalid. */
    expiresAt?: Maybe<Scalars['DateTime']['output']>;
    firstCharacters: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    permissions: Array<Scalars['String']['output']>;
    /** A list of resource levels, their assigned resources, and the granted permissions on each resource. */
    resolvedResourcePermissionGroups: Array<ResolvedResourcePermissionGroup>;
    resources: ResourceAssignment;
    title: Scalars['String']['output'];
};
/** Organization-scoped access token. */
export type OrganizationAccessTokenResolvedResourcePermissionGroupsArgs = {
    includeAll?: Scalars['Boolean']['input'];
};
export type OrganizationAccessTokenConnection = {
    __typename?: 'OrganizationAccessTokenConnection';
    edges: Array<OrganizationAccessTokenEdge>;
    pageInfo: PageInfo;
};
export type OrganizationAccessTokenEdge = {
    __typename?: 'OrganizationAccessTokenEdge';
    cursor: Scalars['String']['output'];
    node: OrganizationAccessToken;
};
/** Reference input for identifying an organization access token. */
export type OrganizationAccessTokenReference = 
/** Identify the access token by its unique ID. */
{
    byId: Scalars['ID']['input'];
};
export type OrganizationByInviteCodePayload = OrganizationInvitationError | OrganizationInvitationPayload;
export type OrganizationConnection = {
    __typename?: 'OrganizationConnection';
    nodes: Array<Organization>;
    total: Scalars['Int']['output'];
};
export type OrganizationGetStarted = {
    __typename?: 'OrganizationGetStarted';
    checkingSchema: Scalars['Boolean']['output'];
    creatingProject: Scalars['Boolean']['output'];
    enablingUsageBasedBreakingChanges: Scalars['Boolean']['output'];
    invitingMembers: Scalars['Boolean']['output'];
    publishingSchema: Scalars['Boolean']['output'];
    reportingOperations: Scalars['Boolean']['output'];
};
export type OrganizationInvitation = {
    __typename?: 'OrganizationInvitation';
    code: Scalars['String']['output'];
    createdAt: Scalars['DateTime']['output'];
    email: Scalars['String']['output'];
    expiresAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    role: MemberRole;
};
export type OrganizationInvitationConnection = {
    __typename?: 'OrganizationInvitationConnection';
    edges: Array<OrganizationInvitationEdge>;
    pageInfo: PageInfo;
};
export type OrganizationInvitationEdge = {
    __typename?: 'OrganizationInvitationEdge';
    cursor: Scalars['String']['output'];
    node: OrganizationInvitation;
};
export type OrganizationInvitationError = {
    __typename?: 'OrganizationInvitationError';
    message: Scalars['String']['output'];
};
export type OrganizationInvitationPayload = {
    __typename?: 'OrganizationInvitationPayload';
    name: Scalars['String']['output'];
};
export type OrganizationMemberInput = {
    organizationSlug: Scalars['String']['input'];
    userId: Scalars['ID']['input'];
};
export type OrganizationPayload = {
    __typename?: 'OrganizationPayload';
    organization: Organization;
    selector: OrganizationSelector;
};
/** Reference input for identifying an organization. */
export type OrganizationReferenceInput = 
/** Select an organization using its unique ID. */
{
    byId: Scalars['ID']['input'];
    bySelector?: never;
} | /** Select an organization using a selector (e.g., slug-based selection). */ {
    byId?: never;
    bySelector: OrganizationSelectorInput;
};
export type OrganizationSelector = {
    __typename?: 'OrganizationSelector';
    organizationSlug: Scalars['String']['output'];
};
export type OrganizationSelectorInput = {
    organizationSlug: Scalars['String']['input'];
};
export type OrganizationTransfer = {
    __typename?: 'OrganizationTransfer';
    organization: Organization;
};
export type OrganizationTransferRequestSelector = {
    code: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
};
export type OrganizationUsageEstimationInput = {
    /** The calendar month, 1 to 12, where 1 is January and 12 is December. */
    month: Scalars['Int']['input'];
    /** The 4 digit year. E.g. 2025 */
    year: Scalars['Int']['input'];
};
export type PageInfo = {
    __typename?: 'PageInfo';
    endCursor: Scalars['String']['output'];
    hasNextPage: Scalars['Boolean']['output'];
    hasPreviousPage: Scalars['Boolean']['output'];
    startCursor: Scalars['String']['output'];
};
export type Permission = {
    __typename?: 'Permission';
    dependsOnId?: Maybe<Scalars['ID']['output']>;
    description: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** Whether this permission is assignable by the current viewer. */
    isAssignableByViewer: Scalars['Boolean']['output'];
    isReadOnly: Scalars['Boolean']['output'];
    level: PermissionLevelType;
    title: Scalars['String']['output'];
    warning?: Maybe<Scalars['String']['output']>;
};
export type PermissionGroup = {
    __typename?: 'PermissionGroup';
    id: Scalars['ID']['output'];
    permissions: Array<Permission>;
    title: Scalars['String']['output'];
};
export declare enum PermissionLevelType {
    AppDeployment = "APP_DEPLOYMENT",
    Organization = "ORGANIZATION",
    Project = "PROJECT",
    Service = "SERVICE",
    Target = "TARGET"
}
export type PersonalAccessToken = AccessToken & {
    __typename?: 'PersonalAccessToken';
    createdAt: Scalars['DateTime']['output'];
    description?: Maybe<Scalars['String']['output']>;
    /** If set, then this is when the token will expire and become invalid. */
    expiresAt?: Maybe<Scalars['DateTime']['output']>;
    firstCharacters: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** A list of the resource levels, the assigned resources and the granted permissions on each of those resources. */
    resolvedResourcePermissionGroups: Array<ResolvedResourcePermissionGroup>;
    title: Scalars['String']['output'];
};
export type PersonalAccessTokenResolvedResourcePermissionGroupsArgs = {
    includeAll?: Scalars['Boolean']['input'];
};
export type PersonalAccessTokenConnection = {
    __typename?: 'PersonalAccessTokenConnection';
    edges: Array<PersonalAccessTokenEdge>;
    pageInfo: PageInfo;
};
export type PersonalAccessTokenEdge = {
    __typename?: 'PersonalAccessTokenEdge';
    cursor: Scalars['String']['output'];
    node: PersonalAccessToken;
};
export type PreflightScript = {
    __typename?: 'PreflightScript';
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    sourceCode: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
};
export type PreflightScriptError = Error & {
    __typename?: 'PreflightScriptError';
    message: Scalars['String']['output'];
};
export type PreflightScriptOk = {
    __typename?: 'PreflightScriptOk';
    preflightScript: PreflightScript;
    updatedTarget: Target;
};
/** @oneOf */
export type PreflightScriptResult = {
    __typename?: 'PreflightScriptResult';
    error?: Maybe<PreflightScriptError>;
    ok?: Maybe<PreflightScriptOk>;
};
export type Project = {
    __typename?: 'Project';
    /** Access token for project. */
    accessToken?: Maybe<ProjectAccessToken>;
    /** Paginated list of access tokens issued for the project. */
    accessTokens: ProjectAccessTokenConnection;
    alertChannels?: Maybe<Array<AlertChannel>>;
    alerts?: Maybe<Array<Alert>>;
    /** Permissions that the viewer can assign to project access tokens. */
    availableProjectAccessTokenPermissionGroups: Array<PermissionGroup>;
    buildUrl?: Maybe<Scalars['String']['output']>;
    /** @deprecated Use the 'slug' field instead. */
    cleanId: Scalars['ID']['output'];
    createdAt: Scalars['DateTime']['output'];
    experimental_nativeCompositionPerTarget: Scalars['Boolean']['output'];
    externalSchemaComposition?: Maybe<ExternalSchemaComposition>;
    id: Scalars['ID']['output'];
    isNativeFederationEnabled: Scalars['Boolean']['output'];
    isProjectNameInGitHubCheckEnabled: Scalars['Boolean']['output'];
    /** @deprecated Use the 'slug' field instead. */
    name: Scalars['String']['output'];
    /** Get the status of the native federation compatability for the project. */
    nativeFederationCompatibility: NativeCompositionCompatibility;
    parentSchemaPolicy?: Maybe<SchemaPolicy>;
    requestsOverTime: Array<RequestsOverTime>;
    schemaPolicy?: Maybe<SchemaPolicy>;
    schemaVersionsCount: Scalars['Int']['output'];
    slug: Scalars['String']['output'];
    targetBySlug?: Maybe<Target>;
    targets: TargetConnection;
    totalRequests: Scalars['SafeInt']['output'];
    type: ProjectType;
    validationUrl?: Maybe<Scalars['String']['output']>;
    /** Whether the viewer can create a new target within this project. */
    viewerCanCreateTarget: Scalars['Boolean']['output'];
    /** Whether the viewer can delete this project. */
    viewerCanDelete: Scalars['Boolean']['output'];
    /** Whether the user can manage the access tokens in this project. */
    viewerCanManageProjectAccessTokens: Scalars['Boolean']['output'];
    /** Whether the viewer can view and modify alerts with this project. */
    viewerCanModifyAlerts: Scalars['Boolean']['output'];
    /** Whether the viewer can view and modify the schema policy for this organization */
    viewerCanModifySchemaPolicy: Scalars['Boolean']['output'];
    /** Whether the viewer can access the settings page and modify settings of this project. */
    viewerCanModifySettings: Scalars['Boolean']['output'];
};
export type ProjectAccessTokenArgs = {
    id: Scalars['ID']['input'];
};
export type ProjectAccessTokensArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type ProjectRequestsOverTimeArgs = {
    period: DateRangeInput;
    resolution: Scalars['Int']['input'];
};
export type ProjectSchemaVersionsCountArgs = {
    period?: InputMaybe<DateRangeInput>;
};
export type ProjectTargetBySlugArgs = {
    targetSlug: Scalars['String']['input'];
};
export type ProjectTotalRequestsArgs = {
    period: DateRangeInput;
};
export declare enum ProjectAccessScope {
    Alerts = "ALERTS",
    Delete = "DELETE",
    OperationsStoreRead = "OPERATIONS_STORE_READ",
    OperationsStoreWrite = "OPERATIONS_STORE_WRITE",
    Read = "READ",
    Settings = "SETTINGS"
}
/** Project-scoped access token. */
export type ProjectAccessToken = AccessToken & {
    __typename?: 'ProjectAccessToken';
    createdAt: Scalars['DateTime']['output'];
    description?: Maybe<Scalars['String']['output']>;
    /** If set, then this is when the token will expire and become invalid. */
    expiresAt?: Maybe<Scalars['DateTime']['output']>;
    firstCharacters: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** A list of resource levels, their assigned resources, and the granted permissions on each resource. */
    resolvedResourcePermissionGroups: Array<ResolvedResourcePermissionGroup>;
    title: Scalars['String']['output'];
};
/** Project-scoped access token. */
export type ProjectAccessTokenResolvedResourcePermissionGroupsArgs = {
    includeAll?: Scalars['Boolean']['input'];
};
export type ProjectAccessTokenConnection = {
    __typename?: 'ProjectAccessTokenConnection';
    edges: Array<ProjectAccessTokenEdge>;
    pageInfo: PageInfo;
};
export type ProjectAccessTokenEdge = {
    __typename?: 'ProjectAccessTokenEdge';
    cursor: Scalars['String']['output'];
    node: ProjectAccessToken;
};
export type ProjectConnection = {
    __typename?: 'ProjectConnection';
    edges: Array<ProjectEdge>;
    pageInfo: PageInfo;
};
export type ProjectEdge = {
    __typename?: 'ProjectEdge';
    cursor: Scalars['String']['output'];
    node: Project;
};
/** Represents a project and its associated targets for resource selection. */
export type ProjectForResourceSelector = {
    __typename?: 'ProjectForResourceSelector';
    /** Unique identifier of the project. */
    projectId: Scalars['ID']['output'];
    /** Human-readable slug of the project. */
    slug: Scalars['String']['output'];
    /** Gat a specific target that belongs to the project and can be selected as resource. */
    target?: Maybe<TargetForResourceSelector>;
    /** List of targets that belong to the project and can be selected as resources. */
    targets: Array<TargetForResourceSelector>;
    /** Type of the project. */
    type: ProjectType;
};
/** Represents a project and its associated targets for resource selection. */
export type ProjectForResourceSelectorTargetArgs = {
    targetId: Scalars['ID']['input'];
};
export type ProjectReferenceInput = {
    byId: Scalars['ID']['input'];
    bySelector?: never;
} | {
    byId?: never;
    bySelector: ProjectSelectorInput;
};
export type ProjectResourceAssignment = {
    __typename?: 'ProjectResourceAssignment';
    project: Project;
    projectId: Scalars['ID']['output'];
    targets: ProjectTargetsResourceAssignment;
};
export type ProjectResourceAssignmentInput = {
    projectId: Scalars['ID']['input'];
    targets: ProjectTargetsResourceAssignmentInput;
};
export type ProjectSelector = {
    __typename?: 'ProjectSelector';
    organizationSlug: Scalars['String']['output'];
    projectSlug: Scalars['String']['output'];
};
export type ProjectSelectorInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
};
export type ProjectTargetsResourceAssignment = {
    __typename?: 'ProjectTargetsResourceAssignment';
    mode: ResourceAssignmentModeType;
    targets?: Maybe<Array<TargetResouceAssignment>>;
};
export type ProjectTargetsResourceAssignmentInput = {
    /** Whether the permissions should apply for all targets within the project or only selected ones. */
    mode: ResourceAssignmentModeType;
    /** Specific targets within the projects for which the permissions should be applied. */
    targets?: InputMaybe<Array<TargetResourceAssignmentInput>>;
};
export declare enum ProjectType {
    Federation = "FEDERATION",
    Single = "SINGLE",
    Stitching = "STITCHING"
}
export type PromotionSchemaLog = {
    __typename?: 'PromotionSchemaLog';
    /** The origin of this schema log promotion. */
    _?: Maybe<Scalars['Boolean']['output']>;
};
export declare enum ProposalCompositionStatus {
    Error = "ERROR",
    Success = "SUCCESS"
}
export type PushedSchemaLog = {
    __typename?: 'PushedSchemaLog';
    author: Scalars['String']['output'];
    commit: Scalars['ID']['output'];
    date: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    /** The previous SDL of the pushed schema. Is null for single schema projects. */
    previousServiceSdl?: Maybe<Scalars['String']['output']>;
    /** The name of the service that got published. */
    service?: Maybe<Scalars['String']['output']>;
    /** The serviceSDL of the pushed schema. Is null for single schema projects. */
    serviceSdl?: Maybe<Scalars['String']['output']>;
};
export type Query = {
    __typename?: 'Query';
    admin: AdminQuery;
    billingPlans: Array<BillingPlan>;
    clientStatsByTargets: ClientStatsValuesConnection;
    fieldListStats: Array<FieldStatsValues>;
    fieldStats: FieldStatsValues;
    hasCollectedOperations: Scalars['Boolean']['output'];
    /** Whether the CDN integration in Hive is enabled. */
    isCDNEnabled: Scalars['Boolean']['output'];
    isGitHubIntegrationFeatureEnabled: Scalars['Boolean']['output'];
    lab?: Maybe<Lab>;
    latestValidVersion?: Maybe<SchemaVersion>;
    /** Requires API Token */
    latestVersion?: Maybe<SchemaVersion>;
    me: User;
    monthlyUsage: Array<MonthlyUsage>;
    myDefaultOrganization?: Maybe<OrganizationPayload>;
    organization?: Maybe<Organization>;
    organizationByGitHubInstallationId?: Maybe<Organization>;
    organizationByInviteCode?: Maybe<OrganizationByInviteCodePayload>;
    organizationBySlug?: Maybe<Organization>;
    organizationTransferRequest?: Maybe<OrganizationTransfer>;
    organizations: OrganizationConnection;
    project?: Maybe<Project>;
    schemaPolicyRules: Array<SchemaPolicyRule>;
    schemaProposal?: Maybe<SchemaProposal>;
    schemaProposals?: Maybe<SchemaProposalConnection>;
    /** Returns the latest SchemaVersion associated with a specific commit */
    schemaVersionByCommit?: Maybe<SchemaVersion>;
    /** @deprecated Use Query.schemaVersionByCommit */
    schemaVersionForActionId?: Maybe<SchemaVersion>;
    target?: Maybe<Target>;
    targets: TargetConnection;
    testExternalSchemaComposition: TestExternalSchemaCompositionResult;
    tokenInfo: TokenInfoPayload;
    tokens: TokenConnection;
    usageEstimation: UsageEstimation;
    /**
     * Returns information about the currently authorized actor,
     * including permission details.
     */
    whoAmI?: Maybe<WhoAmI>;
};
export type QueryClientStatsByTargetsArgs = {
    selector: ClientStatsByTargetsInput;
};
export type QueryFieldListStatsArgs = {
    selector: FieldListStatsInput;
};
export type QueryFieldStatsArgs = {
    selector: FieldStatsInput;
};
export type QueryHasCollectedOperationsArgs = {
    selector: TargetSelectorInput;
};
export type QueryLabArgs = {
    selector: TargetSelectorInput;
};
export type QueryLatestValidVersionArgs = {
    target?: InputMaybe<TargetReferenceInput>;
};
export type QueryMonthlyUsageArgs = {
    selector: OrganizationSelectorInput;
};
export type QueryMyDefaultOrganizationArgs = {
    previouslyVisitedOrganizationId?: InputMaybe<Scalars['ID']['input']>;
};
export type QueryOrganizationArgs = {
    reference: OrganizationReferenceInput;
};
export type QueryOrganizationByGitHubInstallationIdArgs = {
    installation: Scalars['ID']['input'];
};
export type QueryOrganizationByInviteCodeArgs = {
    code: Scalars['String']['input'];
};
export type QueryOrganizationBySlugArgs = {
    organizationSlug: Scalars['String']['input'];
};
export type QueryOrganizationTransferRequestArgs = {
    selector: OrganizationTransferRequestSelector;
};
export type QueryProjectArgs = {
    reference: ProjectReferenceInput;
};
export type QuerySchemaProposalArgs = {
    input: SchemaProposalInput;
};
export type QuerySchemaProposalsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: Scalars['Int']['input'];
    input: SchemaProposalsInput;
};
export type QuerySchemaVersionByCommitArgs = {
    commit: Scalars['String']['input'];
    target?: InputMaybe<TargetReferenceInput>;
};
export type QuerySchemaVersionForActionIdArgs = {
    actionId: Scalars['ID']['input'];
    target?: InputMaybe<TargetReferenceInput>;
};
export type QueryTargetArgs = {
    reference: TargetReferenceInput;
};
export type QueryTargetsArgs = {
    selector: ProjectSelectorInput;
};
export type QueryTestExternalSchemaCompositionArgs = {
    selector: TestExternalSchemaCompositionInput;
};
export type QueryTokensArgs = {
    selector: TargetSelectorInput;
};
export type QueryUsageEstimationArgs = {
    input: UsageEstimationInput;
};
export type RateLimit = {
    __typename?: 'RateLimit';
    /** @deprecated Use Organization.isMonthlyOperationsLimitExceeded */
    limitedForOperations: Scalars['Boolean']['output'];
    /** @deprecated Use Organization.monthlyOperationsLimit */
    operations: Scalars['SafeInt']['output'];
    /** @deprecated Use Organization.usageRetentionInDays */
    retentionInDays: Scalars['Int']['output'];
};
export type RateLimitInput = {
    operations: Scalars['SafeInt']['input'];
};
export type RegisterOidcDomainInput = {
    domainName: Scalars['String']['input'];
    oidcIntegrationId: Scalars['ID']['input'];
};
export type RegisterOidcDomainResult = {
    __typename?: 'RegisterOIDCDomainResult';
    error?: Maybe<RegisterOidcDomainResultError>;
    ok?: Maybe<RegisterOidcDomainResultOk>;
};
export type RegisterOidcDomainResultError = {
    __typename?: 'RegisterOIDCDomainResultError';
    message: Scalars['String']['output'];
};
export type RegisterOidcDomainResultOk = {
    __typename?: 'RegisterOIDCDomainResultOk';
    createdOIDCIntegrationDomain: OidcIntegrationDomain;
    oidcIntegration: OidcIntegration;
};
export type RegistryLog = DeletedSchemaLog | PromotionSchemaLog | PushedSchemaLog;
export type ReplyToSchemaProposalReviewError = Error & {
    __typename?: 'ReplyToSchemaProposalReviewError';
    message: Scalars['String']['output'];
};
export type ReplyToSchemaProposalReviewInput = {
    body: Scalars['String']['input'];
    schemaProposalReviewId: Scalars['ID']['input'];
};
export type ReplyToSchemaProposalReviewOk = {
    __typename?: 'ReplyToSchemaProposalReviewOk';
    reply: SchemaProposalComment;
};
export type ReplyToSchemaProposalReviewResult = {
    __typename?: 'ReplyToSchemaProposalReviewResult';
    error?: Maybe<ReplyToSchemaProposalReviewError>;
    ok?: Maybe<ReplyToSchemaProposalReviewOk>;
};
export type RequestOidcDomainChallengeInput = {
    oidcDomainId: Scalars['ID']['input'];
};
export type RequestOidcDomainChallengeResult = {
    __typename?: 'RequestOIDCDomainChallengeResult';
    error?: Maybe<RequestOidcDomainChallengeResultError>;
    ok?: Maybe<RequestOidcDomainChallengeResultOk>;
};
export type RequestOidcDomainChallengeResultError = {
    __typename?: 'RequestOIDCDomainChallengeResultError';
    message: Scalars['String']['output'];
};
export type RequestOidcDomainChallengeResultOk = {
    __typename?: 'RequestOIDCDomainChallengeResultOk';
    oidcIntegrationDomain?: Maybe<OidcIntegrationDomain>;
};
export type RequestOrganizationTransferError = Error & {
    __typename?: 'RequestOrganizationTransferError';
    message: Scalars['String']['output'];
};
export type RequestOrganizationTransferInput = {
    organizationSlug: Scalars['String']['input'];
    userId: Scalars['ID']['input'];
};
export type RequestOrganizationTransferOk = {
    __typename?: 'RequestOrganizationTransferOk';
    code: Scalars['String']['output'];
    email: Scalars['String']['output'];
};
/** @oneOf */
export type RequestOrganizationTransferResult = {
    __typename?: 'RequestOrganizationTransferResult';
    error?: Maybe<RequestOrganizationTransferError>;
    ok?: Maybe<RequestOrganizationTransferOk>;
};
export type RequestsOverTime = {
    __typename?: 'RequestsOverTime';
    date: Scalars['DateTime']['output'];
    value: Scalars['SafeInt']['output'];
};
/** Represents a specific permission and whether it is currently granted to the user or actor. */
export type ResolvedPermission = {
    __typename?: 'ResolvedPermission';
    /** Indicates whether this permission is currently granted. */
    isGranted: Scalars['Boolean']['output'];
    /** The permission definition, indicating the action or capability being checked. */
    permission: Permission;
};
/** A logical grouping of related permissions, often displayed together in a UI section. */
export type ResolvedPermissionsGroup = {
    __typename?: 'ResolvedPermissionsGroup';
    /** List of resolved permissions that belong to this group. */
    permissions: Array<ResolvedPermission>;
    /** Human-readable title of the permission group (e.g. "Schema Registry" or "Members"). */
    title: Scalars['String']['output'];
};
/**
 * Represents a group of permissions associated with a specific resource level
 * (e.g., organization, project, or item).
 */
export type ResolvedResourcePermissionGroup = {
    __typename?: 'ResolvedResourcePermissionGroup';
    /** The resource level this permission group applies to (e.g., ORGANIZATION, PROJECT). */
    level: PermissionLevelType;
    /** The resolved permission groups under this resource level. */
    resolvedPermissionGroups: Array<ResolvedPermissionsGroup>;
    /**
     * The resource identifiers that are currently valid for this permission group.
     * Some examples:
     * - **Organization.** "the-guild"
     * - **Project** "the-guild/graphql-hive"
     * - **Target** "the-guild/graphql-hive/production"
     * - **Service** "the-guild/graphql-hive/production/service/users"
     * - **App Deployment** "the-guild/graphql-hive/production/appDeployment/production"
     *
     * These ids can also contain wildcards, e.g. "the-guild/graphql-hive/*", to reference all targets in a project.
     * If the field resolves to 'null', the permission group is not granted on any resource.
     */
    resolvedResourceIds?: Maybe<Array<Scalars['String']['output']>>;
    /** Human-readable title describing this permission group. */
    title: Scalars['String']['output'];
};
export type ResourceAssignment = {
    __typename?: 'ResourceAssignment';
    mode: ResourceAssignmentModeType;
    projects?: Maybe<Array<ProjectResourceAssignment>>;
};
export type ResourceAssignmentInput = {
    /** Whether the permissions should apply for all projects within the organization or only selected ones. */
    mode: ResourceAssignmentModeType;
    /** Specific projects within the organization for which the permissions should be applied. */
    projects?: InputMaybe<Array<ProjectResourceAssignmentInput>>;
};
export declare enum ResourceAssignmentModeType {
    /** Apply to all subresouces of the resource. */
    All = "ALL",
    /** Apply to specific subresouces of the resource. */
    Granular = "GRANULAR"
}
/** Defines the intent or context under which a resource selector is used. */
export declare enum ResourceSelectorIntentType {
    /** Indicates administrative intent, typically for management or configuration tasks. */
    Admin = "ADMIN",
    /** Indicates user intent, typically for personal or non-administrative operations. */
    User = "USER"
}
export type RetireAppDeploymentError = Error & {
    __typename?: 'RetireAppDeploymentError';
    message: Scalars['String']['output'];
    /**
     * Details about why protection prevented retirement.
     * Only present when retirement was blocked due to protection rules.
     */
    protectionDetails?: Maybe<AppDeploymentProtectionBlockDetails>;
};
export type RetireAppDeploymentInput = {
    /** The identifying application name */
    appName: Scalars['String']['input'];
    /** The exact version of the application to retire */
    appVersion: Scalars['String']['input'];
    /** Force retirement even if protection rules would prevent it. Disabled by default. */
    force?: Scalars['Boolean']['input'];
    /**
     * If using an organization access token, then a target must be provided.
     * If using a target's access token, then this should be null.
     */
    target?: InputMaybe<TargetReferenceInput>;
};
export type RetireAppDeploymentOk = {
    __typename?: 'RetireAppDeploymentOk';
    retiredAppDeployment: AppDeployment;
};
export type RetireAppDeploymentResult = {
    __typename?: 'RetireAppDeploymentResult';
    error?: Maybe<RetireAppDeploymentError>;
    ok?: Maybe<RetireAppDeploymentOk>;
};
export type ReviewSchemaProposalError = Error & {
    __typename?: 'ReviewSchemaProposalError';
    message: Scalars['String']['output'];
};
export type ReviewSchemaProposalInput = {
    /** The initial comment message attached to the review */
    commentBody?: Scalars['String']['input'];
    /**
     * The schema coordinate being referenced. E.g. "Type.field".
     * If null, then this review is for the entire proposal.
     */
    coordinate?: InputMaybe<Scalars['String']['input']>;
    /** The schema proposal that this review is being made on. */
    schemaProposalId: Scalars['ID']['input'];
    /**
     * The service this review applies to. If the target is a monorepo, then use
     * an empty string.
     */
    serviceName: Scalars['String']['input'];
    /** One or both of stageTransition or initialComment inputs is/are required. */
    stageTransition?: InputMaybe<SchemaProposalStage>;
};
export type ReviewSchemaProposalOk = {
    __typename?: 'ReviewSchemaProposalOk';
    review: SchemaProposalReview;
};
export type ReviewSchemaProposalResult = {
    __typename?: 'ReviewSchemaProposalResult';
    error?: Maybe<ReviewSchemaProposalError>;
    ok?: Maybe<ReviewSchemaProposalOk>;
};
export declare enum RuleInstanceSeverityLevel {
    Error = "ERROR",
    Off = "OFF",
    Warning = "WARNING"
}
export type SavedFilter = {
    __typename?: 'SavedFilter';
    createdAt: Scalars['DateTime']['output'];
    createdBy?: Maybe<User>;
    description?: Maybe<Scalars['String']['output']>;
    filters: InsightsFilterConfiguration;
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
    updatedBy?: Maybe<User>;
    /**
     * Number of metric alert rules that reference this filter. When greater than 0
     * the filter cannot be deleted — it must first be detached from those alerts.
     */
    usedByAlertRulesCount: Scalars['Int']['output'];
    viewerCanDelete: Scalars['Boolean']['output'];
    viewerCanUpdate: Scalars['Boolean']['output'];
    viewsCount: Scalars['Int']['output'];
    visibility: SavedFilterVisibilityType;
};
export type SavedFilterConnection = {
    __typename?: 'SavedFilterConnection';
    edges: Array<SavedFilterEdge>;
    pageInfo: PageInfo;
};
export type SavedFilterEdge = {
    __typename?: 'SavedFilterEdge';
    cursor: Scalars['String']['output'];
    node: SavedFilter;
};
export type SavedFilterError = Error & {
    __typename?: 'SavedFilterError';
    message: Scalars['String']['output'];
};
export declare enum SavedFilterVisibilityType {
    Private = "PRIVATE",
    Shared = "SHARED"
}
export type Schema = CompositeSchema | SingleSchema;
/** Describes a schema change for either a schema version ('SchemaVersion') or schema check ('SchemaCheck'). */
export type SchemaChange = {
    __typename?: 'SchemaChange';
    /**
     * List of active app deployments that would be affected by this breaking change.
     * Only populated for breaking changes when app deployments are enabled.
     */
    affectedAppDeployments?: Maybe<SchemaChangeAffectedAppDeploymentsConnection>;
    /**
     * Approval metadata for this schema change.
     * This field is populated in case the breaking change was manually approved.
     */
    approval?: Maybe<SchemaChangeApproval>;
    /** @deprecated Use 'SchemaChange.severityLevel' instead. This field will be removed once it is no longer in use by a client. */
    criticality: CriticalityLevel;
    /** @deprecated Use 'SchemaChange.severityReason' instead. This field will be removed once it is no longer in use by a client. */
    criticalityReason?: Maybe<Scalars['String']['output']>;
    /** Whether the breaking change is safe based on usage data. */
    isSafeBasedOnUsage: Scalars['Boolean']['output'];
    /** Message describing the schema change. */
    message: Scalars['String']['output'];
    meta?: Maybe<SchemaChangeMeta>;
    path?: Maybe<Array<Scalars['String']['output']>>;
    /**
     * The severity level of this schema change.
     * Note: A schema change with the impact 'SeverityLevelType.BREAKING' can still be safe based on the usage ('SchemaChange.isSafeBasedOnUsage').
     */
    severityLevel: SeverityLevelType;
    /** The reason for the schema changes severity level ('SchemaChange.severityLevel') */
    severityReason?: Maybe<Scalars['String']['output']>;
    /**
     * Usage statistics about the schema change if it is not safe based on usage.
     * The statistics are determined based on the breaking change configuration.
     * The usage statistics are only available for breaking changes and only represent a snapshot of the usage data at the time of the schema check/schema publish.
     */
    usageStatistics?: Maybe<SchemaChangeUsageStatistics>;
};
/** Describes a schema change for either a schema version ('SchemaVersion') or schema check ('SchemaCheck'). */
export type SchemaChangeAffectedAppDeploymentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    firstOperations?: InputMaybe<Scalars['Int']['input']>;
};
/** Describes a schema change for either a schema version ('SchemaVersion') or schema check ('SchemaCheck'). */
export type SchemaChangeMessageArgs = {
    withSafeBasedOnUsageNote?: InputMaybe<Scalars['Boolean']['input']>;
};
/** An app deployment that is affected by a breaking schema change. */
export type SchemaChangeAffectedAppDeployment = {
    __typename?: 'SchemaChangeAffectedAppDeployment';
    /** The timestamp when the app deployment was activated. */
    activatedAt?: Maybe<Scalars['DateTime']['output']>;
    /** The operations within this app deployment that use the affected schema coordinate. */
    affectedOperations: SchemaChangeAffectedAppDeploymentOperationsConnection;
    /** The timestamp when the app deployment was created. */
    createdAt?: Maybe<Scalars['DateTime']['output']>;
    /** The unique identifier of the app deployment. */
    id: Scalars['ID']['output'];
    /** The last time a GraphQL request that used the app deployment was reported. */
    lastUsed?: Maybe<Scalars['DateTime']['output']>;
    /** The name of the app deployment. */
    name: Scalars['String']['output'];
    /** The timestamp when the app deployment was retired. Only present for retired deployments. */
    retiredAt?: Maybe<Scalars['DateTime']['output']>;
    /** The current status of the app deployment. */
    status: AppDeploymentStatus;
    /** Total count of operations within this app deployment that use the affected schema coordinate. */
    totalAffectedOperations: Scalars['Int']['output'];
    /** The version of the app deployment. */
    version: Scalars['String']['output'];
};
/** An app deployment that is affected by a breaking schema change. */
export type SchemaChangeAffectedAppDeploymentAffectedOperationsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type SchemaChangeAffectedAppDeploymentEdge = {
    __typename?: 'SchemaChangeAffectedAppDeploymentEdge';
    cursor: Scalars['String']['output'];
    node: SchemaChangeAffectedAppDeployment;
};
/** An operation within an app deployment that is affected by a breaking schema change. */
export type SchemaChangeAffectedAppDeploymentOperation = {
    __typename?: 'SchemaChangeAffectedAppDeploymentOperation';
    /** The hash of the operation document. */
    hash: Scalars['String']['output'];
    /** The name of the operation (if named). */
    name?: Maybe<Scalars['String']['output']>;
};
export type SchemaChangeAffectedAppDeploymentOperationEdge = {
    __typename?: 'SchemaChangeAffectedAppDeploymentOperationEdge';
    cursor: Scalars['String']['output'];
    node: SchemaChangeAffectedAppDeploymentOperation;
};
export type SchemaChangeAffectedAppDeploymentOperationsConnection = {
    __typename?: 'SchemaChangeAffectedAppDeploymentOperationsConnection';
    edges: Array<SchemaChangeAffectedAppDeploymentOperationEdge>;
    pageInfo: PageInfo;
};
export type SchemaChangeAffectedAppDeploymentsConnection = {
    __typename?: 'SchemaChangeAffectedAppDeploymentsConnection';
    edges: Array<SchemaChangeAffectedAppDeploymentEdge>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type SchemaChangeApproval = {
    __typename?: 'SchemaChangeApproval';
    /** Date of the schema change approval. */
    approvedAt: Scalars['DateTime']['output'];
    /** User that approved this schema change. */
    approvedBy?: Maybe<User>;
    /** CLI approval metadata when approved via CLI (mutually exclusive with approvedBy). */
    cliApprovalMetadata?: Maybe<CliApprovalMetadata>;
    /** ID of the schema check in which this change was first approved. */
    schemaCheckId: Scalars['ID']['output'];
};
export type SchemaChangeConnection = {
    __typename?: 'SchemaChangeConnection';
    edges: Array<SchemaChangeEdge>;
    /** @deprecated Use 'SchemaChangeConnection.edges' instead. */
    nodes: Array<SchemaChange>;
    pageInfo: PageInfo;
    /** @deprecated This field will be removed in the future. */
    total: Scalars['Int']['output'];
};
export type SchemaChangeEdge = {
    __typename?: 'SchemaChangeEdge';
    cursor: Scalars['String']['output'];
    node: SchemaChange;
};
export type SchemaChangeMeta = DirectiveAdded | DirectiveArgumentAdded | DirectiveArgumentDefaultValueChanged | DirectiveArgumentDescriptionChanged | DirectiveArgumentRemoved | DirectiveArgumentTypeChanged | DirectiveDescriptionChanged | DirectiveLocationAdded | DirectiveLocationRemoved | DirectiveRemoved | DirectiveRepeatableAdded | DirectiveRepeatableRemoved | DirectiveUsageArgumentAdded | DirectiveUsageArgumentDefinitionAdded | DirectiveUsageArgumentDefinitionRemoved | DirectiveUsageArgumentRemoved | DirectiveUsageEnumAdded | DirectiveUsageEnumRemoved | DirectiveUsageEnumValueAdded | DirectiveUsageEnumValueRemoved | DirectiveUsageFieldAdded | DirectiveUsageFieldDefinitionAdded | DirectiveUsageFieldDefinitionRemoved | DirectiveUsageFieldRemoved | DirectiveUsageInputFieldDefinitionAdded | DirectiveUsageInputFieldDefinitionRemoved | DirectiveUsageInputObjectAdded | DirectiveUsageInputObjectRemoved | DirectiveUsageInterfaceAdded | DirectiveUsageInterfaceRemoved | DirectiveUsageObjectAdded | DirectiveUsageObjectRemoved | DirectiveUsageScalarAdded | DirectiveUsageScalarRemoved | DirectiveUsageSchemaAdded | DirectiveUsageSchemaRemoved | DirectiveUsageUnionMemberAdded | DirectiveUsageUnionMemberRemoved | EnumValueAdded | EnumValueDeprecationReasonAdded | EnumValueDeprecationReasonChanged | EnumValueDeprecationReasonRemoved | EnumValueDescriptionChanged | EnumValueRemoved | FieldAdded | FieldArgumentAdded | FieldArgumentDefaultChanged | FieldArgumentDescriptionChanged | FieldArgumentRemoved | FieldArgumentTypeChanged | FieldDeprecationAdded | FieldDeprecationReasonAdded | FieldDeprecationReasonChanged | FieldDeprecationReasonRemoved | FieldDeprecationRemoved | FieldDescriptionAdded | FieldDescriptionChanged | FieldDescriptionRemoved | FieldRemoved | FieldTypeChanged | InputFieldAdded | InputFieldDefaultValueChanged | InputFieldDescriptionAdded | InputFieldDescriptionChanged | InputFieldDescriptionRemoved | InputFieldRemoved | InputFieldTypeChanged | ObjectTypeInterfaceAdded | ObjectTypeInterfaceRemoved | SchemaMutationTypeChanged | SchemaQueryTypeChanged | SchemaSubscriptionTypeChanged | TypeAdded | TypeDescriptionAdded | TypeDescriptionChanged | TypeDescriptionRemoved | TypeKindChanged | TypeRemoved | UnionMemberAdded | UnionMemberRemoved;
export type SchemaChangeUsageStatistics = {
    __typename?: 'SchemaChangeUsageStatistics';
    /** List of top clients that are affected by this schema change. */
    topAffectedClients: Array<SchemaChangeUsageStatisticsAffectedClient>;
    /** List of the top operations that are affected by this schema change. */
    topAffectedOperations: Array<SchemaChangeUsageStatisticsAffectedOperation>;
};
export type SchemaChangeUsageStatisticsAffectedClient = {
    __typename?: 'SchemaChangeUsageStatisticsAffectedClient';
    /** The number of times the client called the operation in the period. */
    count: Scalars['Float']['output'];
    /** Human readable count value. */
    countFormatted: Scalars['String']['output'];
    /** Name of the client. */
    name: Scalars['String']['output'];
    /** The percentage share of the client of the total traffic. */
    percentage: Scalars['Float']['output'];
    /** Human readable percentage value. */
    percentageFormatted: Scalars['String']['output'];
};
export type SchemaChangeUsageStatisticsAffectedOperation = {
    __typename?: 'SchemaChangeUsageStatisticsAffectedOperation';
    /** The number of times the operation was called in the period. */
    count: Scalars['Float']['output'];
    /** Human readable count value. */
    countFormatted: Scalars['String']['output'];
    /** Hash of the operation. */
    hash: Scalars['String']['output'];
    /** Name of the operation. */
    name: Scalars['String']['output'];
    /**
     * Get the associated operation.
     * The field is nullable as this data is only stored for the duration of the usage retention period.
     */
    operation?: Maybe<Operation>;
    /** The percentage share of the operation of the total traffic. */
    percentage: Scalars['Float']['output'];
    /** Human readable percentage value. */
    percentageFormatted: Scalars['String']['output'];
};
export type SchemaCheck = {
    breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
    /** 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>;
    schemaChanges?: Maybe<SchemaChangeConnection>;
    schemaPolicyErrors?: Maybe<SchemaPolicyWarningConnection>;
    schemaPolicyWarnings?: Maybe<SchemaPolicyWarningConnection>;
    /**
     * If the check is associated with a schema proposal, then this contains an unfiltered list of changes
     * to the SDL.
     */
    schemaProposalChanges?: Maybe<SchemaChangeConnection>;
    /** 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']>;
    /** The URL of the schema check on the Hive Web App. */
    webUrl?: Maybe<Scalars['String']['output']>;
};
export type SchemaCheckConditionalBreakingChangeMetadata = {
    __typename?: 'SchemaCheckConditionalBreakingChangeMetadata';
    period: DateRange;
    settings: SchemaCheckConditionalBreakingChangeMetadataSettings;
    usage: SchemaCheckConditionalBreakingChangeMetadataUsage;
};
export type SchemaCheckConditionalBreakingChangeMetadataSettings = {
    __typename?: 'SchemaCheckConditionalBreakingChangeMetadataSettings';
    excludedAppDeploymentNames?: Maybe<Array<Scalars['String']['output']>>;
    excludedClientNames?: Maybe<Array<Scalars['String']['output']>>;
    percentage: Scalars['Float']['output'];
    retentionInDays: Scalars['Int']['output'];
    targets: Array<BreakingChangeMetadataTarget>;
};
export type SchemaCheckConditionalBreakingChangeMetadataUsage = {
    __typename?: 'SchemaCheckConditionalBreakingChangeMetadataUsage';
    /** Total amount of requests for the settings and period. */
    totalRequestCount: Scalars['Float']['output'];
    /** Total request count human readable. */
    totalRequestCountFormatted: Scalars['String']['output'];
};
export type SchemaCheckConnection = {
    __typename?: 'SchemaCheckConnection';
    edges: Array<SchemaCheckEdge>;
    pageInfo: PageInfo;
};
export type SchemaCheckEdge = {
    __typename?: 'SchemaCheckEdge';
    cursor: Scalars['String']['output'];
    node: SchemaCheck;
};
export type SchemaCheckError = {
    __typename?: 'SchemaCheckError';
    changes?: Maybe<SchemaChangeConnection>;
    errors: SchemaErrorConnection;
    schemaCheck?: Maybe<SchemaCheck>;
    /**
     * If the check is associated with a schema proposal, then this contains an unfiltered list of changes
     * to the SDL.
     */
    schemaProposalChanges?: Maybe<SchemaChangeConnection>;
    valid: Scalars['Boolean']['output'];
    warnings?: Maybe<SchemaWarningConnection>;
};
export type SchemaCheckInput = {
    /**
     * Optional context ID to group schema checks together.
     * Manually approved breaking changes will be memorized for schema checks with the same context id.
     */
    contextId?: InputMaybe<Scalars['String']['input']>;
    github?: InputMaybe<GitHubSchemaCheckInput>;
    meta?: InputMaybe<SchemaCheckMetaInput>;
    /** Optional. Attaches the check to a schema proposal. */
    schemaProposalId?: InputMaybe<Scalars['ID']['input']>;
    sdl: Scalars['String']['input'];
    service?: InputMaybe<Scalars['ID']['input']>;
    target?: InputMaybe<TargetReferenceInput>;
    /** Optional url if wanting to show subgraph url changes inside checks. */
    url?: InputMaybe<Scalars['String']['input']>;
};
export type SchemaCheckMeta = {
    __typename?: 'SchemaCheckMeta';
    author: Scalars['String']['output'];
    commit: Scalars['String']['output'];
};
export type SchemaCheckMetaInput = {
    author: Scalars['String']['input'];
    commit: Scalars['String']['input'];
};
export type SchemaCheckPayload = GitHubSchemaCheckError | GitHubSchemaCheckSuccess | SchemaCheckError | SchemaCheckSuccess;
export type SchemaCheckSuccess = {
    __typename?: 'SchemaCheckSuccess';
    changes?: Maybe<SchemaChangeConnection>;
    initial: Scalars['Boolean']['output'];
    schemaCheck?: Maybe<SchemaCheck>;
    /**
     * If the check is associated with a schema proposal, then this contains an unfiltered list of changes
     * to the SDL.
     */
    schemaProposalChanges?: Maybe<SchemaChangeConnection>;
    valid: Scalars['Boolean']['output'];
    warnings?: Maybe<SchemaWarningConnection>;
};
export type SchemaCheckWarning = {
    __typename?: 'SchemaCheckWarning';
    column?: Maybe<Scalars['Int']['output']>;
    line?: Maybe<Scalars['Int']['output']>;
    message: Scalars['String']['output'];
    source?: Maybe<Scalars['String']['output']>;
};
export type SchemaChecksFilter = {
    changed?: InputMaybe<Scalars['Boolean']['input']>;
    failed?: InputMaybe<Scalars['Boolean']['input']>;
};
export type SchemaCompareInput = {
    after: Scalars['ID']['input'];
    before: Scalars['ID']['input'];
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
};
export type SchemaComposeError = Error & {
    __typename?: 'SchemaComposeError';
    message: Scalars['String']['output'];
};
export type SchemaComposeInput = {
    services: Array<SchemaComposeServiceInput>;
    target?: InputMaybe<TargetReferenceInput>;
    /**
     * Whether to use the latest composable version or just latest schema version for the composition.
     * Latest schema version may or may not be composable.
     * It's true by default, which means the latest composable schema version is used.
     */
    useLatestComposableVersion?: InputMaybe<Scalars['Boolean']['input']>;
};
export type SchemaComposePayload = SchemaComposeError | SchemaComposeSuccess;
export type SchemaComposeServiceInput = {
    name: Scalars['String']['input'];
    sdl: Scalars['String']['input'];
    url?: InputMaybe<Scalars['String']['input']>;
};
export type SchemaComposeSuccess = {
    __typename?: 'SchemaComposeSuccess';
    compositionResult: SchemaCompositionResult;
    valid: Scalars['Boolean']['output'];
};
export type SchemaCompositionExternalMethodInput = {
    endpoint: Scalars['String']['input'];
    secret: Scalars['String']['input'];
};
export type SchemaCompositionMethodInput = 
/** Use an external schema composition endpoint. */
{
    external: SchemaCompositionExternalMethodInput;
    legacy?: never;
    native?: never;
} | /** Use the legacy federation v1 schema composition. */ {
    external?: never;
    legacy: Scalars['Boolean']['input'];
    native?: never;
} | /** Use the native federation schema composition. This is the default method for new projects. */ {
    external?: never;
    legacy?: never;
    native: Scalars['Boolean']['input'];
};
/** @oneOf */
export type SchemaCompositionResult = {
    __typename?: 'SchemaCompositionResult';
    errors?: Maybe<SchemaErrorConnection>;
    supergraphSdl?: Maybe<Scalars['String']['output']>;
};
export type SchemaConnection = {
    __typename?: 'SchemaConnection';
    edges: Array<SchemaEdge>;
    /** @deprecated Use 'SchemaConnection.edges' instead. */
    nodes: Array<Schema>;
    pageInfo: PageInfo;
    /** @deprecated This field will be removed. */
    total: Scalars['Int']['output'];
};
export type SchemaCoordinateStats = {
    __typename?: 'SchemaCoordinateStats';
    clients: ClientStatsValuesConnection;
    operations: OperationStatsValuesConnection;
    requestsOverTime: Array<RequestsOverTime>;
    supergraphMetadata?: Maybe<SupergraphMetadata>;
    totalRequests: Scalars['SafeInt']['output'];
};
export type SchemaCoordinateStatsRequestsOverTimeArgs = {
    resolution: Scalars['Int']['input'];
};
/** Information about the schema coordinate usage within the contextual period. */
export type SchemaCoordinateUsage = {
    __typename?: 'SchemaCoordinateUsage';
    /** Whether the schema coordinate is used within the contextual period. */
    isUsed: Scalars['Boolean']['output'];
    /** The top operations executed for this schema coordinate within the contextual period. */
    topOperations: Array<SchemaCoordinateUsageOperation>;
    /** The total amount of usages of the schema coordinate within the contextual period. */
    total: Scalars['Float']['output'];
    /**
     * A list of clients that use this schema coordinate within GraphQL operation documents.
     * Is null if used by none clients.
     */
    usedByClients?: Maybe<Array<Scalars['String']['output']>>;
};
/** Information about the schema coordinate usage within the contextual period. */
export type SchemaCoordinateUsageTopOperationsArgs = {
    limit: Scalars['Int']['input'];
};
export type SchemaCoordinateUsageOperation = {
    __typename?: 'SchemaCoordinateUsageOperation';
    /** The number of times the operation was called within the contextual period. */
    count: Scalars['Float']['output'];
    /** The hash of the GraphQL operation */
    hash: Scalars['String']['output'];
    /** The name of the GraphQL operation. */
    name: Scalars['String']['output'];
};
export type SchemaDeleteError = {
    __typename?: 'SchemaDeleteError';
    errors: SchemaErrorConnection;
    valid: Scalars['Boolean']['output'];
};
export type SchemaDeleteInput = {
    dryRun?: InputMaybe<Scalars['Boolean']['input']>;
    serviceName: Scalars['ID']['input'];
    target?: InputMaybe<TargetReferenceInput>;
};
export type SchemaDeleteResult = SchemaDeleteError | SchemaDeleteSuccess;
export type SchemaDeleteSuccess = {
    __typename?: 'SchemaDeleteSuccess';
    changes?: Maybe<SchemaChangeConnection>;
    errors: SchemaErrorConnection;
    valid: Scalars['Boolean']['output'];
};
export type SchemaEdge = {
    __typename?: 'SchemaEdge';
    cursor: Scalars['String']['output'];
    node: Schema;
};
export type SchemaError = {
    __typename?: 'SchemaError';
    message: Scalars['String']['output'];
    path?: Maybe<Array<Scalars['String']['output']>>;
};
export type SchemaErrorConnection = {
    __typename?: 'SchemaErrorConnection';
    edges: Array<SchemaErrorEdge>;
    /** @deprecated Use 'SchemaErrorConnection.edges' instead. */
    nodes: Array<SchemaError>;
    pageInfo: PageInfo;
    /** @deprecated This field will be removed in the future. */
    total: Scalars['Int']['output'];
};
export type SchemaErrorEdge = {
    __typename?: 'SchemaErrorEdge';
    cursor: Scalars['String']['output'];
    node: SchemaError;
};
export type SchemaExplorer = {
    __typename?: 'SchemaExplorer';
    metadataAttributes?: Maybe<Array<MetadataAttribute>>;
    mutation?: Maybe<GraphQlObjectType>;
    query?: Maybe<GraphQlObjectType>;
    subscription?: Maybe<GraphQlObjectType>;
    type?: Maybe<GraphQlNamedType>;
    types: Array<GraphQlNamedType>;
};
export type SchemaExplorerTypeArgs = {
    name: Scalars['String']['input'];
};
export type SchemaExplorerPeriodInput = 
/** A full range using a start and end date. */
{
    absoluteRange: DateRangeInput;
};
export type SchemaExplorerUsageInput = {
    period: DateRangeInput;
};
export type SchemaMetadata = {
    __typename?: 'SchemaMetadata';
    /** The value of the metadata */
    content: Scalars['String']['output'];
    /** The name or key of the metadata. This may not be unique. */
    name: Scalars['String']['output'];
    /** The schema or subgraph name where this metadata originated from. */
    source?: Maybe<Scalars['String']['output']>;
};
export type SchemaMutationTypeChanged = {
    __typename?: 'SchemaMutationTypeChanged';
    newMutationTypeName: Scalars['String']['output'];
    oldMutationTypeName: Scalars['String']['output'];
};
export type SchemaPolicy = {
    __typename?: 'SchemaPolicy';
    allowOverrides: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
    rules: Array<SchemaPolicyRuleInstance>;
    updatedAt: Scalars['DateTime']['output'];
};
export type SchemaPolicyInput = {
    rules: Array<SchemaPolicyRuleInstanceInput>;
};
export declare enum SchemaPolicyLevel {
    Organization = "ORGANIZATION",
    Project = "PROJECT"
}
export type SchemaPolicyRule = {
    __typename?: 'SchemaPolicyRule';
    configJsonSchema?: Maybe<Scalars['JSONSchemaObject']['output']>;
    description: Scalars['String']['output'];
    documentationUrl?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    recommended: Scalars['Boolean']['output'];
};
export type SchemaPolicyRuleInstance = {
    __typename?: 'SchemaPolicyRuleInstance';
    configuration?: Maybe<Scalars['JSON']['output']>;
    rule: SchemaPolicyRule;
    severity: RuleInstanceSeverityLevel;
};
export type SchemaPolicyRuleInstanceInput = {
    configuration?: InputMaybe<Scalars['JSON']['input']>;
    ruleId: Scalars['String']['input'];
    severity: RuleInstanceSeverityLevel;
};
export type SchemaPolicyWarning = {
    __typename?: 'SchemaPolicyWarning';
    end?: Maybe<CodePosition>;
    message: Scalars['String']['output'];
    ruleId?: Maybe<Scalars['String']['output']>;
    start?: Maybe<CodePosition>;
};
export type SchemaPolicyWarningConnection = {
    __typename?: 'SchemaPolicyWarningConnection';
    edges: Array<SchemaPolicyWarningEdge>;
    pageInfo: PageInfo;
};
export type SchemaPolicyWarningEdge = {
    __typename?: 'SchemaPolicyWarningEdge';
    cursor: Scalars['String']['output'];
    node: SchemaPolicyWarning;
};
export type SchemaProposal = {
    __typename?: 'SchemaProposal';
    /**
     * The author of the proposal. If no author has been assigned, then this returns an empty string.
     * The author is taken from the author of the oldest check ran for this proposal.
     */
    author: Scalars['String']['output'];
    /**
     * The checks associated with this proposal. Each proposed change triggers a check
     * for the set of changes. And each service is checked separately. This is a limitation
     * of the schema check API at this time.
     *
     * The check "cursor" can be considered the proposal "version".
     */
    checks?: Maybe<SchemaCheckConnection>;
    compositionStatus?: Maybe<ProposalCompositionStatus>;
    compositionStatusReason?: Maybe<Scalars['String']['output']>;
    compositionTimestamp?: Maybe<Scalars['DateTime']['output']>;
    createdAt: Scalars['DateTime']['output'];
    /** The proposal description. If no description was given, this will be an empty string. */
    description: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    /** Applies changes to each service subgraph for each of the service's latest check belonging to the SchemaProposal. */
    rebasedSchemaSDL?: Maybe<SchemaConnection>;
    /** Applies changes to the supergraph for each of the service's latest check belonging to the SchemaProposal. */
    rebasedSupergraphSDL?: Maybe<Scalars['String']['output']>;
    /** A paginated list of reviews. */
    reviews?: Maybe<SchemaProposalReviewConnection>;
    /**
     * The current stage of the proposal. Proposals should be transitioned through the
     * course of the review from DRAFT, OPEN, APPROVED, IMPLEMENTED, but may be CLOSED
     * at any point in its lifecycle prior to being IMPLEMENTED. DRAFT, OPEN, APPROVED,
     * and CLOSED may be triggered by user action. But IMPLEMENTED can only happen if
     * the target schema contains the proposed changes while the proposal is in the
     * APPROVED state.
     */
    stage: SchemaProposalStage;
    /**
     * A short title of this proposal. Meant to give others an easy way to refer to this
     * set of changes.
     */
    title: Scalars['String']['output'];
    /** When the proposal was last modified. Adding a review or comment does not count. */
    updatedAt: Scalars['DateTime']['output'];
};
export type SchemaProposalChecksArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: Scalars['Int']['input'];
    input: SchemaProposalChecksInput;
};
export type SchemaProposalRebasedSchemaSdlArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: Scalars['Int']['input'];
};
export type SchemaProposalRebasedSupergraphSdlArgs = {
    fromCursor?: InputMaybe<Scalars['String']['input']>;
};
export type SchemaProposalReviewsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: Scalars['Int']['input'];
};
export type SchemaProposalChecksInput = {
    /** Set to "true" to only return the latest checks for each service. */
    latestPerService?: Scalars['Boolean']['input'];
};
export type SchemaProposalComment = {
    __typename?: 'SchemaProposalComment';
    /** The stored author of this comment. Does not update if a user changes their name for the time being. */
    author: Scalars['String']['output'];
    /** Content of this comment. E.g. "Nice job!" */
    body: Scalars['String']['output'];
    /** When the comment was initially posted */
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    /** If edited, then when it was last edited. */
    updatedAt?: Maybe<Scalars['DateTime']['output']>;
};
export type SchemaProposalCommentConnection = {
    __typename?: 'SchemaProposalCommentConnection';
    edges?: Maybe<Array<SchemaProposalCommentEdge>>;
    pageInfo: PageInfo;
};
export type SchemaProposalCommentEdge = {
    __typename?: 'SchemaProposalCommentEdge';
    cursor: Scalars['String']['output'];
    node: SchemaProposalComment;
};
export type SchemaProposalCompositionEvent = {
    __typename?: 'SchemaProposalCompositionEvent';
    status: ProposalCompositionStatus;
    timestamp: Scalars['String']['output'];
};
export type SchemaProposalCompositionSubscriptionInput = {
    proposalId: Scalars['ID']['input'];
};
export type SchemaProposalConnection = {
    __typename?: 'SchemaProposalConnection';
    edges?: Maybe<Array<SchemaProposalEdge>>;
    pageInfo: PageInfo;
};
export type SchemaProposalEdge = {
    __typename?: 'SchemaProposalEdge';
    cursor: Scalars['String']['output'];
    node: SchemaProposal;
};
export type SchemaProposalInput = {
    /** Unique identifier of the desired SchemaProposal */
    id: Scalars['ID']['input'];
};
export type SchemaProposalReview = {
    __typename?: 'SchemaProposalReview';
    /** The stored author of this review. Does not update if a user changes their name for the time being. */
    author: Scalars['String']['output'];
    /** Comments attached to this review. */
    comments?: Maybe<SchemaProposalCommentConnection>;
    /**
     * When the review was first made. Only a review's comments are mutable, so there is no
     * updatedAt on the review.
     */
    createdAt: Scalars['DateTime']['output'];
    /** A UUID unique to this review. Used for querying. */
    id: Scalars['ID']['output'];
    /**
     * The text on the line at the time of being reviewed. This should be displayed if that
     * coordinate's text has been modified
     *
     * If the "lineText" is null then this review references the entire SchemaProposalVersion
     * and not any specific line within the proposal.
     */
    lineText?: Maybe<Scalars['String']['output']>;
    /**
     * The coordinate being referenced by this review. This is the most accurate location and should be used prior
     * to falling back to the lineNumber. Only if this coordinate does not exist in the comparing schema, should the line number be used.
     */
    schemaCoordinate?: Maybe<Scalars['String']['output']>;
    /**
     * Name of the service if reviewing a specific service's schema.
     * Else an empty string.
     */
    serviceName: Scalars['String']['output'];
    /**
     * If null then this review is just a comment. Otherwise, the reviewer changed the state of the
     * proposal as part of their review. E.g. The reviewer can approve a version with a comment.
     */
    stageTransition?: Maybe<SchemaProposalStage>;
};
export type SchemaProposalReviewCommentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: Scalars['Int']['input'];
};
export type SchemaProposalReviewConnection = {
    __typename?: 'SchemaProposalReviewConnection';
    edges?: Maybe<Array<SchemaProposalReviewEdge>>;
    pageInfo: PageInfo;
};
export type SchemaProposalReviewEdge = {
    __typename?: 'SchemaProposalReviewEdge';
    cursor: Scalars['String']['output'];
    node: SchemaProposalReview;
};
export declare enum SchemaProposalStage {
    Approved = "APPROVED",
    Closed = "CLOSED",
    Draft = "DRAFT",
    Implemented = "IMPLEMENTED",
    Open = "OPEN"
}
export type SchemaProposalsInput = {
    stages?: InputMaybe<Array<SchemaProposalStage>>;
    target: TargetReferenceInput;
};
export type SchemaPublishError = {
    __typename?: 'SchemaPublishError';
    changes?: Maybe<SchemaChangeConnection>;
    errors: SchemaErrorConnection;
    linkToWebsite?: Maybe<Scalars['String']['output']>;
    valid: Scalars['Boolean']['output'];
};
export type SchemaPublishGitHubInput = {
    /** The commit sha. */
    commit: Scalars['String']['input'];
    /** The repository name. */
    repository: Scalars['String']['input'];
};
export type SchemaPublishInput = {
    author: Scalars['String']['input'];
    commit: Scalars['String']['input'];
    /**
     * Accept breaking changes and mark schema as valid (if composable)
     * @deprecated Enabled by default for newly created projects
     */
    experimental_acceptBreakingChanges?: InputMaybe<Scalars['Boolean']['input']>;
    /** @deprecated Enabled by default for newly created projects */
    force?: InputMaybe<Scalars['Boolean']['input']>;
    /** Link GitHub version to a GitHub commit on a repository. */
    gitHub?: InputMaybe<SchemaPublishGitHubInput>;
    /**
     * Talk to GitHub Application and create a check-run
     * @deprecated Use SchemaPublishInput.gitHub instead.
     */
    github?: InputMaybe<Scalars['Boolean']['input']>;
    metadata?: InputMaybe<Scalars['String']['input']>;
    sdl: Scalars['String']['input'];
    service?: InputMaybe<Scalars['ID']['input']>;
    /** Whether the CLI supports retrying the schema publish, in case acquiring the schema publish lock fails due to a busy queue. */
    supportsRetry?: InputMaybe<Scalars['Boolean']['input']>;
    target?: InputMaybe<TargetReferenceInput>;
    url?: InputMaybe<Scalars['String']['input']>;
};
export type SchemaPublishMissingServiceError = {
    __typename?: 'SchemaPublishMissingServiceError';
    message: Scalars['String']['output'];
};
export type SchemaPublishMissingUrlError = {
    __typename?: 'SchemaPublishMissingUrlError';
    message: Scalars['String']['output'];
};
export type SchemaPublishPayload = GitHubSchemaPublishError | GitHubSchemaPublishSuccess | SchemaPublishError | SchemaPublishMissingServiceError | SchemaPublishMissingUrlError | SchemaPublishRetry | SchemaPublishSuccess;
export type SchemaPublishRetry = {
    __typename?: 'SchemaPublishRetry';
    reason: Scalars['String']['output'];
};
export type SchemaPublishSuccess = {
    __typename?: 'SchemaPublishSuccess';
    changes?: Maybe<SchemaChangeConnection>;
    initial: Scalars['Boolean']['output'];
    linkToWebsite?: Maybe<Scalars['String']['output']>;
    message?: Maybe<Scalars['String']['output']>;
    valid: Scalars['Boolean']['output'];
};
export type SchemaQueryTypeChanged = {
    __typename?: 'SchemaQueryTypeChanged';
    newQueryTypeName: Scalars['String']['output'];
    oldQueryTypeName: Scalars['String']['output'];
};
export type SchemaSubscriptionTypeChanged = {
    __typename?: 'SchemaSubscriptionTypeChanged';
    newSubscriptionTypeName: Scalars['String']['output'];
    oldSubscriptionTypeName: Scalars['String']['output'];
};
export type SchemaVersion = {
    __typename?: 'SchemaVersion';
    baseSchema?: Maybe<Scalars['String']['output']>;
    breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
    /** Contract versions of this schema version. */
    contractVersions?: Maybe<ContractVersionConnection>;
    /** The data on which this schema version was published. */
    date: Scalars['DateTime']['output'];
    /** An overview of deprecated fields and types with their usage in the GraphQL schema. */
    deprecatedSchema?: Maybe<DeprecatedSchemaExplorer>;
    /** Experimental: This field is not stable and may change in the future. */
    explorer?: Maybe<SchemaExplorer>;
    /** GitHub metadata associated with the schema version. */
    githubMetadata?: Maybe<SchemaVersionGithubMetadata>;
    /** Whether this schema version has schema changes. */
    hasSchemaChanges: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
    /** Whether this schema version is composable. */
    isComposable: Scalars['Boolean']['output'];
    /** Whether this is the first composable schema version. */
    isFirstComposableVersion: Scalars['Boolean']['output'];
    /** A schema version is valid if the composition and contract compositions are successful. */
    isValid: Scalars['Boolean']['output'];
    /**
     * The log that initiated this schema version.
     * For a federation schema this is the published or removed subgraph/service.
     * @deprecated Please use 'SchemaVersion.origin' instead.
     */
    log: RegistryLog;
    /** Additional metadata associated with the schema version that help identifying it. */
    meta?: Maybe<SchemaVersionMeta>;
    origin: SchemaVersionOrigin;
    /** The schema version against which this schema version was compared to in order to determine schema changes. */
    previousDiffableSchemaVersion?: Maybe<SchemaVersion>;
    safeSchemaChanges?: Maybe<SchemaChangeConnection>;
    /** Schema changes that were introduced in this schema version (compared to the previous version). */
    schemaChanges?: Maybe<SchemaChangeConnection>;
    schemaCompositionErrors?: Maybe<SchemaErrorConnection>;
    /**
     * The schemas that are composed within this schema version.
     * For federation these are the subgraphs/services.
     */
    schemas: SchemaConnection;
    /** The (public) schema SDL. */
    sdl?: Maybe<Scalars['String']['output']>;
    /**
     * The diffs of the individual services compared to the latest version.
     * This is only available for non monolithic projects.
     */
    subgraphDiffs?: Maybe<Array<SubgraphDiff>>;
    /** The supergraph SDL for a federation schema. */
    supergraph?: Maybe<Scalars['String']['output']>;
    /** A list of the supergraph changes. */
    supergraphChanges?: Maybe<SchemaChangeConnection>;
    /**
     * List of tags in the schema version. E.g. when using Federation.
     * Tags can be used for filtering the schema via contracts.
     */
    tags?: Maybe<Array<Scalars['String']['output']>>;
    /** An overview of unused fields and their types within the GraphQL schema. */
    unusedSchema?: Maybe<UnusedSchemaExplorer>;
    /**
     * A schema version is valid if the composition and contract compositions are successful.
     * @deprecated Use 'SchemaVersion.isValid' instead.
     */
    valid: Scalars['Boolean']['output'];
};
export type SchemaVersionDeprecatedSchemaArgs = {
    period?: InputMaybe<SchemaExplorerPeriodInput>;
};
export type SchemaVersionExplorerArgs = {
    usage?: InputMaybe<SchemaExplorerUsageInput>;
};
export type SchemaVersionUnusedSchemaArgs = {
    period?: InputMaybe<SchemaExplorerPeriodInput>;
};
export type SchemaVersionConnection = {
    __typename?: 'SchemaVersionConnection';
    edges: Array<SchemaVersionEdge>;
    pageInfo: PageInfo;
};
export type SchemaVersionEdge = {
    __typename?: 'SchemaVersionEdge';
    cursor: Scalars['String']['output'];
    node: SchemaVersion;
};
export type SchemaVersionGithubMetadata = {
    __typename?: 'SchemaVersionGithubMetadata';
    commit: Scalars['String']['output'];
    repository: Scalars['String']['output'];
};
export type SchemaVersionMeta = {
    __typename?: 'SchemaVersionMeta';
    /** The author of the schema version */
    author?: Maybe<Scalars['String']['output']>;
    /** A user associated string that helps identifying the schema version. */
    commit?: Maybe<Scalars['String']['output']>;
};
/** Describes the action that caused the creation of a new SchemaVersion. */
export type SchemaVersionOrigin = SchemaVersionPromoteOrigin | SchemaVersionPublishOrigin | SchemaVersionSubgraphRemoveOrigin;
/**
 * Input for a schema version promotion.
 * Both the source and target must be within the same project.
 */
export type SchemaVersionPromoteInput = {
    /**
     * The source of the schema promotion.
     * This can either be a target or a specific schema version.
     */
    source: SchemaVersionPromoteSourceInput;
    /** Where the schema version should be promoted to. */
    target: SchemaVersionPromoteTargetInput;
};
export type SchemaVersionPromoteOrigin = {
    __typename?: 'SchemaVersionPromoteOrigin';
    /** The exact ID of the schema version that was promoted from within the target. */
    schemaVersionId: Scalars['ID']['output'];
    /** The ID of the target from which the promotion originated. */
    targetId: Scalars['ID']['output'];
    /** The slug of the target from which the promotion originated. */
    targetSlug: Scalars['String']['output'];
};
export type SchemaVersionPromoteResult = {
    __typename?: 'SchemaVersionPromoteResult';
    error?: Maybe<SchemaVersionPromoteResultError>;
    ok?: Maybe<SchemaVersionPromoteResultOk>;
};
export type SchemaVersionPromoteResultError = {
    __typename?: 'SchemaVersionPromoteResultError';
    message: Scalars['String']['output'];
};
export type SchemaVersionPromoteResultOk = {
    __typename?: 'SchemaVersionPromoteResultOk';
    /** The link for viewing the new schema version on the Hive Console dashboard. */
    linkToWebsite?: Maybe<Scalars['String']['output']>;
    /** The new schema version that was created via the promotion. */
    newSchemaVersion: SchemaVersion;
};
export type SchemaVersionPromoteSourceInput = 
/** A specific version should be promoted. */
{
    fromSchemaVersionById: Scalars['ID']['input'];
    fromTarget?: never;
} | /** The latest version within the target should be promoted. */ {
    fromSchemaVersionById?: never;
    fromTarget: TargetReferenceInput;
};
export type SchemaVersionPromoteTargetInput = {
    toTarget: TargetReferenceInput;
};
export type SchemaVersionPublishOrigin = {
    __typename?: 'SchemaVersionPublishOrigin';
    /**
     * The subgraphs published as part of this version.
     * This value is 'null' for non-federation projects.
     */
    publishedSubgraphs?: Maybe<Array<SubgraphOriginSubgraphReference>>;
};
export type SchemaVersionSubgraphRemoveOrigin = {
    __typename?: 'SchemaVersionSubgraphRemoveOrigin';
    /** The subgraphs that were removed in this version. */
    removedSubgraphs: Array<SubgraphOriginSubgraphReference>;
};
export type SchemaVersionUpdateInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
    valid: Scalars['Boolean']['input'];
    versionId: Scalars['ID']['input'];
};
export type SchemaWarningConnection = {
    __typename?: 'SchemaWarningConnection';
    nodes: Array<SchemaCheckWarning>;
    total: Scalars['Int']['output'];
};
export type SendVerificationEmailError = Error & {
    __typename?: 'SendVerificationEmailError';
    emailAlreadyVerified: Scalars['Boolean']['output'];
    message: Scalars['String']['output'];
};
export type SendVerificationEmailInput = {
    resend?: InputMaybe<Scalars['Boolean']['input']>;
    userIdentityId: Scalars['ID']['input'];
};
export type SendVerificationEmailOk = {
    __typename?: 'SendVerificationEmailOk';
    expiresAt: Scalars['DateTime']['output'];
};
/** @oneOf */
export type SendVerificationEmailResult = {
    __typename?: 'SendVerificationEmailResult';
    error?: Maybe<SendVerificationEmailError>;
    ok?: Maybe<SendVerificationEmailOk>;
};
export type ServiceResourceAssignmentInput = {
    serviceName: Scalars['String']['input'];
};
/** Describes the impact of a schema change. */
export declare enum SeverityLevelType {
    /** The change will definetly break GraphQL client users. */
    Breaking = "BREAKING",
    /**
     * The change might break existing clients that do not follow
     * best-practises such as future-proof enums or future-proof interface/union type usages.
     */
    Dangerous = "DANGEROUS",
    /** The change is safe and does not break existing clients. */
    Safe = "SAFE"
}
export type SingleSchema = {
    __typename?: 'SingleSchema';
    author: Scalars['String']['output'];
    commit: Scalars['ID']['output'];
    date: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    metadata?: Maybe<Scalars['String']['output']>;
    source: Scalars['String']['output'];
};
export type SlackChannelInput = {
    channel: Scalars['String']['input'];
};
export declare enum SortDirectionType {
    Asc = "ASC",
    Desc = "DESC"
}
export type Span = {
    __typename?: 'Span';
    duration: Scalars['SafeInt']['output'];
    endTime: Scalars['DateTime64']['output'];
    events: Array<SpanEvent>;
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    parentId?: Maybe<Scalars['ID']['output']>;
    resourceAttributes: Scalars['JSONObject']['output'];
    spanAttributes: Scalars['JSONObject']['output'];
    startTime: Scalars['DateTime64']['output'];
    traceId: Scalars['ID']['output'];
};
export type SpanEvent = {
    __typename?: 'SpanEvent';
    attributes: Scalars['JSONObject']['output'];
    date: Scalars['DateTime64']['output'];
    name: Scalars['String']['output'];
};
/** Describes the difference from one subgraph version to the next one. */
export type SubgraphDiff = SubgraphDiffAdded | SubgraphDiffChanged | SubgraphDiffRemoved | SubgraphDiffUnchanged;
/** The subgraph was newly added and did not exist before in the supergraph. */
export type SubgraphDiffAdded = {
    __typename?: 'SubgraphDiffAdded';
    /** The added subgraph version. */
    subgraphVersion: SubgraphVersion;
};
/** The subgraph was updated to a new version. */
export type SubgraphDiffChanged = {
    __typename?: 'SubgraphDiffChanged';
    /** The changes from one to the next subgraph version. */
    changes?: Maybe<SchemaChangeConnection>;
    /** The previous subgraph version. */
    previousSubgraphVersion: SubgraphVersion;
    /** The current subgraph version. */
    subgraphVersion: SubgraphVersion;
};
/** The subgraph was removed from the supergraph. */
export type SubgraphDiffRemoved = {
    __typename?: 'SubgraphDiffRemoved';
    /** The subgraph version that was removed. */
    removedSubgraphVersion: SubgraphVersion;
};
/** The subgraph is unchanged in this version. */
export type SubgraphDiffUnchanged = {
    __typename?: 'SubgraphDiffUnchanged';
    /** The current subgraph version. */
    subgraphVersion: SubgraphVersion;
};
export type SubgraphOriginSubgraphReference = {
    __typename?: 'SubgraphOriginSubgraphReference';
    name: Scalars['String']['output'];
    versionId: Scalars['ID']['output'];
};
export type SubgraphVersion = {
    __typename?: 'SubgraphVersion';
    /** The ID of the subgraph. */
    id: Scalars['ID']['output'];
    /** The subgraph SDL. */
    sdl: Scalars['String']['output'];
    /** The service name. */
    serviceName: Scalars['String']['output'];
    /** The URL of the Subgraph. */
    url: Scalars['String']['output'];
};
export type Subscription = {
    __typename?: 'Subscription';
    /**
     * Subscribe to logs from the OIDC provider integration.
     * Helpful for debugging failing logins.
     */
    oidcIntegrationLog: OidcIntegrationLogEvent;
    schemaProposalComposition: SchemaProposalCompositionEvent;
};
export type SubscriptionOidcIntegrationLogArgs = {
    input: OidcIntegrationLogSubscriptionInput;
};
export type SubscriptionSchemaProposalCompositionArgs = {
    input: SchemaProposalCompositionSubscriptionInput;
};
/** A successful schema check. */
export type SuccessfulSchemaCheck = SchemaCheck & {
    __typename?: 'SuccessfulSchemaCheck';
    /** Comment given when the schema check was approved. */
    approvalComment?: Maybe<Scalars['String']['output']>;
    /** The user that approved the schema check. */
    approvedBy?: Maybe<User>;
    /** Breaking changes can exist in an successful schema check if the check was manually approved. */
    breakingSchemaChanges?: Maybe<SchemaChangeConnection>;
    /** CLI approval metadata when approved via CLI (mutually exclusive with approvedBy). */
    cliApprovalMetadata?: Maybe<CliApprovalMetadata>;
    compositeSchemaSDL?: Maybe<Scalars['String']['output']>;
    /** 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'];
    /** Whether the schema check was manually approved. */
    isApproved: Scalars['Boolean']['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>;
    schemaChanges?: Maybe<SchemaChangeConnection>;
    /** Schema policy errors can exist in an successful schema check if the check was manually approved. */
    schemaPolicyErrors?: Maybe<SchemaPolicyWarningConnection>;
    schemaPolicyWarnings?: Maybe<SchemaPolicyWarningConnection>;
    /**
     * If the check is associated with a schema proposal, then this contains an unfiltered list of changes
     * to the SDL.
     */
    schemaProposalChanges?: Maybe<SchemaChangeConnection>;
    /** 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 SupergraphMetadata = {
    __typename?: 'SupergraphMetadata';
    metadata?: Maybe<Array<SchemaMetadata>>;
    /**
     * List of service names that own the field/type.
     * Resolves to null if the entity (field, type, scalar) does not belong to any service.
     */
    ownedByServiceNames?: Maybe<Array<Scalars['String']['output']>>;
};
export type SupportTicket = {
    __typename?: 'SupportTicket';
    comments?: Maybe<SupportTicketCommentConnection>;
    createdAt: Scalars['DateTime']['output'];
    description: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    priority: SupportTicketPriority;
    status: SupportTicketStatus;
    subject: Scalars['String']['output'];
    updatedAt: Scalars['DateTime']['output'];
};
export type SupportTicketComment = {
    __typename?: 'SupportTicketComment';
    body: Scalars['String']['output'];
    createdAt: Scalars['DateTime']['output'];
    fromSupport: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
};
export type SupportTicketCommentConnection = {
    __typename?: 'SupportTicketCommentConnection';
    edges: Array<SupportTicketCommentEdge>;
    pageInfo: PageInfo;
};
export type SupportTicketCommentEdge = {
    __typename?: 'SupportTicketCommentEdge';
    cursor: Scalars['String']['output'];
    node: SupportTicketComment;
};
export type SupportTicketConnection = {
    __typename?: 'SupportTicketConnection';
    edges: Array<SupportTicketEdge>;
    pageInfo: PageInfo;
};
export type SupportTicketCreateInput = {
    description: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
    priority: SupportTicketPriority;
    subject: Scalars['String']['input'];
};
/** @oneOf */
export type SupportTicketCreateResult = {
    __typename?: 'SupportTicketCreateResult';
    error?: Maybe<SupportTicketCreateResultError>;
    ok?: Maybe<SupportTicketCreateResultOk>;
};
export type SupportTicketCreateResultError = Error & {
    __typename?: 'SupportTicketCreateResultError';
    message: Scalars['String']['output'];
};
export type SupportTicketCreateResultOk = {
    __typename?: 'SupportTicketCreateResultOk';
    supportTicketId: Scalars['ID']['output'];
};
export type SupportTicketEdge = {
    __typename?: 'SupportTicketEdge';
    cursor: Scalars['String']['output'];
    node: SupportTicket;
};
export declare enum SupportTicketPriority {
    High = "HIGH",
    Normal = "NORMAL",
    Urgent = "URGENT"
}
export type SupportTicketReplyInput = {
    body: Scalars['String']['input'];
    organizationSlug: Scalars['String']['input'];
    ticketId: Scalars['String']['input'];
};
/** @oneOf */
export type SupportTicketReplyResult = {
    __typename?: 'SupportTicketReplyResult';
    error?: Maybe<SupportTicketReplyResultError>;
    ok?: Maybe<SupportTicketReplyResultOk>;
};
export type SupportTicketReplyResultError = Error & {
    __typename?: 'SupportTicketReplyResultError';
    message: Scalars['String']['output'];
};
export type SupportTicketReplyResultOk = {
    __typename?: 'SupportTicketReplyResultOk';
    supportTicketId: Scalars['ID']['output'];
};
export declare enum SupportTicketStatus {
    Open = "OPEN",
    Solved = "SOLVED"
}
export type Target = {
    __typename?: 'Target';
    /**
     * Find active app deployments matching specific criteria.
     * Date filter conditions (lastUsedBefore, neverUsedAndCreatedBefore) use OR semantics.
     * If no date filters are provided, all active deployments are returned.
     * The name filter uses AND semantics to narrow results.
     * Only active deployments are returned (not pending or retired).
     */
    activeAppDeployments: AppDeploymentConnection;
    /** Get a list of paginated schema contracts that are active for the target. */
    activeContracts: ContractConnection;
    appDeployment?: Maybe<AppDeployment>;
    /** Configuration for app deployment retirement protection. */
    appDeploymentProtectionConfiguration: AppDeploymentProtectionConfiguration;
    /** The app deployments for this target. */
    appDeployments?: Maybe<AppDeploymentConnection>;
    baseSchema?: Maybe<Scalars['String']['output']>;
    /** A paginated connection of CDN tokens for accessing this target's artifacts. */
    cdnAccessTokens: TargetCdnAccessTokenConnection;
    /** The URL for accessing this target's artifacts via the CDN. */
    cdnUrl: Scalars['String']['output'];
    /** @deprecated Use the 'slug' field instead. */
    cleanId: Scalars['ID']['output'];
    /** Retrieve statistics for a clients usage. */
    clientStats: ClientStats;
    /** Configuration for conditional breaking change detection. */
    conditionalBreakingChangeConfiguration: ConditionalBreakingChangeConfiguration;
    /** Get a list of paginated schema contracts for the target. */
    contracts: ContractConnection;
    documentCollection?: Maybe<DocumentCollection>;
    documentCollectionOperation?: Maybe<DocumentCollectionOperation>;
    documentCollections: DocumentCollectionConnection;
    experimental_forcedLegacySchemaComposition: Scalars['Boolean']['output'];
    /** Whether a dangerous change fails a schema check and requires a manual approval. */
    failDiffOnDangerousChange: Scalars['Boolean']['output'];
    /**
     * The endpoint url of the target's explorer/laboratory instance.
     * This is the public endpoint configured in target's settings.
     */
    graphqlEndpointUrl?: Maybe<Scalars['String']['output']>;
    /** Whether any subscription operations were reported for this target. */
    hasCollectedSubscriptionOperations: Scalars['Boolean']['output'];
    hasSchema: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
    /** The latest (potentially invalid) schema version. */
    latestSchemaVersion?: Maybe<SchemaVersion>;
    /** The latest valid (composable) schema version. */
    latestValidSchemaVersion?: Maybe<SchemaVersion>;
    /**
     * A single metric alert rule scoped to this target. Returns null if the id does not
     * resolve to a rule belonging to this target.
     */
    metricAlertRule?: Maybe<MetricAlertRule>;
    /** State changes across all alert rules for this target (powers the alert events chart + list). */
    metricAlertRuleStateLog: Array<MetricAlertRuleStateChange>;
    metricAlertRules: Array<MetricAlertRule>;
    /**
     * Maximum metric alert rules permitted per target. Flat across all plans.
     * The frontend reads this to render an "X of N rules" indicator and to
     * disable the "Add rule" affordance when the cap is reached.
     */
    metricAlertRulesLimit: Scalars['Int']['output'];
    /**
     * How many days of alert state-log history are retained for the organization
     * that owns this target. Plan-gated; HOBBY/PRO get 7 days, ENTERPRISE gets 30.
     * The frontend uses this to bound the activity-page date-range picker.
     */
    metricAlertStateLogRetentionDays: Scalars['Int']['output'];
    /** @deprecated Use the 'slug' field instead. */
    name: Scalars['String']['output'];
    /** Retrieve an operation via it's hash. */
    operation?: Maybe<Operation>;
    /** Retrieve an overview of all operation statistics. */
    operationsStats: OperationsStats;
    preflightScript?: Maybe<PreflightScript>;
    project: Project;
    requestsOverTime: Array<RequestsOverTime>;
    savedFilter?: Maybe<SavedFilter>;
    savedFilters: SavedFilterConnection;
    /** Get a schema check for the target by ID. */
    schemaCheck?: Maybe<SchemaCheck>;
    /** Get a list of paginated schema checks for a target. */
    schemaChecks: SchemaCheckConnection;
    /** Retrieve statistics over a schema coordinates usage. */
    schemaCoordinateStats: SchemaCoordinateStats;
    /** Retreive a specific schema version in this target by it's id. */
    schemaVersion?: Maybe<SchemaVersion>;
    /** Paginated list of schema versions, ordered from recent to oldest. */
    schemaVersions: SchemaVersionConnection;
    schemaVersionsCount: Scalars['Int']['output'];
    slug: Scalars['String']['output'];
    tokens: TokenConnection;
    totalRequests: Scalars['SafeInt']['output'];
    trace?: Maybe<Trace>;
    traces: TraceConnection;
    tracesFilterOptions: TracesFilterOptions;
    tracesStatusBreakdown: Array<TraceStatusBreakdownBucket>;
    viewerCanAccessSettings: Scalars['Boolean']['output'];
    /** Whether the viewer can access OTEL traces */
    viewerCanAccessTraces: Scalars['Boolean']['output'];
    viewerCanCreateSavedFilter: Scalars['Boolean']['output'];
    viewerCanDelete: Scalars['Boolean']['output'];
    viewerCanModifyCDNAccessToken: Scalars['Boolean']['output'];
    viewerCanModifyLaboratory: Scalars['Boolean']['output'];
    viewerCanModifyPreflightScript: Scalars['Boolean']['output'];
    viewerCanModifySettings: Scalars['Boolean']['output'];
    viewerCanModifyTargetAccessToken: Scalars['Boolean']['output'];
    viewerCanShareSavedFilter: Scalars['Boolean']['output'];
    /**
     * True when the cluster-wide kill-switch is enabled OR this organization has
     * opted in via its per-org feature flag. Used by the frontend to hide alert
     * routes/links when neither gate allows the feature.
     */
    viewerCanUseMetricAlertRules: Scalars['Boolean']['output'];
    /** Whether the viewer can access the app deployments within a target. */
    viewerCanViewAppDeployments: Scalars['Boolean']['output'];
    viewerCanViewLaboratory: Scalars['Boolean']['output'];
    viewerCanViewSchemaProposals: Scalars['Boolean']['output'];
};
export type TargetActiveAppDeploymentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter: ActiveAppDeploymentsFilter;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetActiveContractsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetAppDeploymentArgs = {
    appName: Scalars['String']['input'];
    appVersion: Scalars['String']['input'];
};
export type TargetAppDeploymentsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<AppDeploymentsSortInput>;
};
export type TargetCdnAccessTokensArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetClientStatsArgs = {
    clientName: Scalars['String']['input'];
    period: DateRangeInput;
};
export type TargetContractsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetDocumentCollectionArgs = {
    id: Scalars['ID']['input'];
};
export type TargetDocumentCollectionOperationArgs = {
    id: Scalars['ID']['input'];
};
export type TargetDocumentCollectionsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetMetricAlertRuleArgs = {
    id: Scalars['ID']['input'];
};
export type TargetMetricAlertRuleStateLogArgs = {
    from: Scalars['DateTime']['input'];
    to: Scalars['DateTime']['input'];
};
export type TargetOperationArgs = {
    hash: Scalars['ID']['input'];
};
export type TargetOperationsStatsArgs = {
    filter?: InputMaybe<OperationStatsFilterInput>;
    period: DateRangeInput;
};
export type TargetRequestsOverTimeArgs = {
    period: DateRangeInput;
    resolution: Scalars['Int']['input'];
};
export type TargetSavedFilterArgs = {
    id: Scalars['ID']['input'];
};
export type TargetSavedFiltersArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    search?: InputMaybe<Scalars['String']['input']>;
    visibility?: InputMaybe<SavedFilterVisibilityType>;
};
export type TargetSchemaCheckArgs = {
    id: Scalars['ID']['input'];
};
export type TargetSchemaChecksArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filters?: InputMaybe<SchemaChecksFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetSchemaCoordinateStatsArgs = {
    period: DateRangeInput;
    schemaCoordinate: Scalars['String']['input'];
};
export type TargetSchemaVersionArgs = {
    id: Scalars['ID']['input'];
};
export type TargetSchemaVersionsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type TargetSchemaVersionsCountArgs = {
    period?: InputMaybe<DateRangeInput>;
};
export type TargetTotalRequestsArgs = {
    period: DateRangeInput;
};
export type TargetTraceArgs = {
    traceId: Scalars['ID']['input'];
};
export type TargetTracesArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<TracesFilterInput>;
    first?: InputMaybe<Scalars['Int']['input']>;
    sort?: InputMaybe<TracesSortInput>;
};
export type TargetTracesFilterOptionsArgs = {
    filter?: InputMaybe<TracesFilterInput>;
};
export type TargetTracesStatusBreakdownArgs = {
    filter?: InputMaybe<TracesFilterInput>;
};
export declare enum TargetAccessScope {
    Delete = "DELETE",
    Read = "READ",
    RegistryRead = "REGISTRY_READ",
    RegistryWrite = "REGISTRY_WRITE",
    Settings = "SETTINGS",
    TokensRead = "TOKENS_READ",
    TokensWrite = "TOKENS_WRITE"
}
export type TargetAppDeploymentsResourceAssignment = {
    __typename?: 'TargetAppDeploymentsResourceAssignment';
    appDeployments?: Maybe<Array<Scalars['String']['output']>>;
    mode: ResourceAssignmentModeType;
};
export type TargetAppDeploymentsResourceAssignmentInput = {
    /** Specific app deployments within the target for which the permissions should be applied. */
    appDeployments?: InputMaybe<Array<AppDeploymentResourceAssignmentInput>>;
    /** Whether the permissions should apply for all app deployments within the target. */
    mode: ResourceAssignmentModeType;
};
export type TargetCdnAccessTokenConnection = {
    __typename?: 'TargetCdnAccessTokenConnection';
    edges: Array<TargetCdnAccessTokenEdge>;
    pageInfo: PageInfo;
};
export type TargetCdnAccessTokenEdge = {
    __typename?: 'TargetCdnAccessTokenEdge';
    cursor: Scalars['String']['output'];
    node: CdnAccessToken;
};
export type TargetConnection = {
    __typename?: 'TargetConnection';
    edges: Array<TargetEdge>;
    pageInfo: PageInfo;
};
export type TargetEdge = {
    __typename?: 'TargetEdge';
    cursor: Scalars['String']['output'];
    node: Target;
};
/** Represents a target and its selectable sub-resources for resource selection. */
export type TargetForResourceSelector = {
    __typename?: 'TargetForResourceSelector';
    /** List of application deployment identifiers available under this target. */
    appDeployments?: Maybe<Array<Scalars['String']['output']>>;
    /** List of service identifiers available under this target. Empty if not existing (no federation or stitching project). */
    services?: Maybe<Array<Scalars['String']['output']>>;
    /** Human-readable slug of the target. */
    slug: Scalars['String']['output'];
    /** Unique identifier of the target. */
    targetId: Scalars['ID']['output'];
};
/** Reference to a target. */
export type TargetReferenceInput = 
/** Reference to a target using it's ID (see "Target.id" field). */
{
    byId: Scalars['ID']['input'];
    bySelector?: never;
} | /** Reference to a target using it's slug parts (see "Organization.slug", "Project.slug", "Target.slug"). */ {
    byId?: never;
    bySelector: TargetSelectorInput;
};
export type TargetResouceAssignment = {
    __typename?: 'TargetResouceAssignment';
    appDeployments: TargetAppDeploymentsResourceAssignment;
    services: TargetServicesResourceAssignment;
    target: Target;
    targetId: Scalars['ID']['output'];
};
export type TargetResourceAssignmentInput = {
    appDeployments: TargetAppDeploymentsResourceAssignmentInput;
    services: TargetServicesResourceAssignmentInput;
    targetId: Scalars['ID']['input'];
};
export type TargetSelector = {
    __typename?: 'TargetSelector';
    organizationSlug: Scalars['String']['output'];
    projectSlug: Scalars['String']['output'];
    targetSlug: Scalars['String']['output'];
};
export type TargetSelectorInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
};
export type TargetServicesResourceAssignment = {
    __typename?: 'TargetServicesResourceAssignment';
    mode: ResourceAssignmentModeType;
    services?: Maybe<Array<Scalars['String']['output']>>;
};
export type TargetServicesResourceAssignmentInput = {
    /** Whether the permissions should apply for all services within the target or only selected ones. */
    mode: ResourceAssignmentModeType;
    /** Specific services within the target for which the permissions should be applied. */
    services?: InputMaybe<Array<ServiceResourceAssignmentInput>>;
};
export type TeamsWebhookChannel = AlertChannel & {
    __typename?: 'TeamsWebhookChannel';
    endpoint: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    name: Scalars['String']['output'];
    type: AlertChannelType;
};
export type TestExternalSchemaCompositionError = Error & {
    __typename?: 'TestExternalSchemaCompositionError';
    message: Scalars['String']['output'];
};
export type TestExternalSchemaCompositionInput = {
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
};
/** @oneOf */
export type TestExternalSchemaCompositionResult = {
    __typename?: 'TestExternalSchemaCompositionResult';
    error?: Maybe<TestExternalSchemaCompositionError>;
    ok?: Maybe<Project>;
};
export type Token = {
    __typename?: 'Token';
    alias: Scalars['String']['output'];
    date: Scalars['DateTime']['output'];
    id: Scalars['ID']['output'];
    lastUsedAt?: Maybe<Scalars['DateTime']['output']>;
    name: Scalars['String']['output'];
};
export type TokenConnection = {
    __typename?: 'TokenConnection';
    nodes: Array<Token>;
    total: Scalars['Int']['output'];
};
export declare enum TokenExpirationPeriod {
    Never = "NEVER",
    OneMonth = "ONE_MONTH",
    OneWeek = "ONE_WEEK",
    OneYear = "ONE_YEAR",
    SixMonths = "SIX_MONTHS",
    TwoWeeks = "TWO_WEEKS"
}
export type TokenInfo = {
    __typename?: 'TokenInfo';
    hasOrganizationScope: Scalars['Boolean']['output'];
    hasProjectScope: Scalars['Boolean']['output'];
    hasTargetScope: Scalars['Boolean']['output'];
    organization: Organization;
    project: Project;
    target: Target;
    token: Token;
};
export type TokenInfoHasOrganizationScopeArgs = {
    scope: OrganizationAccessScope;
};
export type TokenInfoHasProjectScopeArgs = {
    scope: ProjectAccessScope;
};
export type TokenInfoHasTargetScopeArgs = {
    scope: TargetAccessScope;
};
export type TokenInfoPayload = TokenInfo | TokenNotFoundError;
export type TokenNotFoundError = {
    __typename?: 'TokenNotFoundError';
    message: Scalars['String']['output'];
};
export type Trace = {
    __typename?: 'Trace';
    /**
     * The client name.
     * Usually this is the 'x-graphql-client-name' or 'graphql-client-name' header sent to the gateway.
     */
    clientName?: Maybe<Scalars['String']['output']>;
    /**
     * The client version.
     * Usually this is the 'x-graphql-client-version' or 'graphql-client-version' header sent to the gateway.
     */
    clientVersion?: Maybe<Scalars['String']['output']>;
    /** Total duration of the trace. */
    duration: Scalars['SafeInt']['output'];
    httpHost?: Maybe<Scalars['String']['output']>;
    httpMethod?: Maybe<Scalars['String']['output']>;
    httpRoute?: Maybe<Scalars['String']['output']>;
    httpStatusCode?: Maybe<Scalars['String']['output']>;
    httpUrl?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    /** The Hash of the GraphQL operation. */
    operationHash?: Maybe<Scalars['ID']['output']>;
    operationName?: Maybe<Scalars['String']['output']>;
    operationType?: Maybe<GraphQlOperationType>;
    spans: Array<Span>;
    /** The subgraphs called within the trace. */
    subgraphs?: Maybe<Array<Scalars['String']['output']>>;
    /**
     * Wether the trace is successful.
     * A trace is a success if no GraphQL errors occured and the HTTP status code is in the 2XX to 3XX range.
     */
    success: Scalars['Boolean']['output'];
    timestamp: Scalars['DateTime']['output'];
};
export type TraceConnection = {
    __typename?: 'TraceConnection';
    edges: Array<TraceEdge>;
    pageInfo: PageInfo;
};
export type TraceEdge = {
    __typename?: 'TraceEdge';
    cursor: Scalars['String']['output'];
    node: Trace;
};
export type TraceStatusBreakdownBucket = {
    __typename?: 'TraceStatusBreakdownBucket';
    /** Total mount of error traces in the bucket based on the filter. */
    errorCountFiltered: Scalars['SafeInt']['output'];
    /** Total amount of error traces in the bucket. */
    errorCountTotal: Scalars['SafeInt']['output'];
    /** Total amount of ok traces in the bucket based on the filter. */
    okCountFiltered: Scalars['SafeInt']['output'];
    /** Total amount of ok traces in the bucket. */
    okCountTotal: Scalars['SafeInt']['output'];
    /** The end of the time bucket for the data */
    timeBucketEnd: Scalars['DateTime']['output'];
    /** The time bucket for the data */
    timeBucketStart: Scalars['DateTime']['output'];
};
export type TracesFilterInput = {
    /** Filter based on the client name. */
    clientNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Duration filter for the traces. */
    duration?: InputMaybe<DurationInput>;
    /** Filter based on GraphQL error codes (error.extensions.code). */
    errorCodes?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the HTTP host of the request. */
    httpHosts?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the HTTP method of the request. */
    httpMethods?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the HTTP route of the request. */
    httpRoutes?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the HTTP status code of the request. */
    httpStatusCodes?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the HTTP URL of the request. */
    httpUrls?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Filter based on the operation name. */
    operationNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /**
     * Filter based on the operation type.
     *
     * A value of 'null' value indicates a unknown operation type.
     */
    operationTypes?: InputMaybe<Array<InputMaybe<GraphQlOperationType>>>;
    /** Time range filter for the traces. */
    period?: InputMaybe<DateRangeInput>;
    /** Filter based on called subgraphs. */
    subgraphNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /**
     * Filter based on whether the operation is a success.
     * A operation is successful if no GraphQL error has occured and the result is within the 2XX or 3XX range.
     */
    success?: InputMaybe<Array<Scalars['Boolean']['input']>>;
    /** Filter based on trace ID. */
    traceIds?: InputMaybe<Array<Scalars['ID']['input']>>;
};
export type TracesFilterOptions = {
    __typename?: 'TracesFilterOptions';
    clientName: Array<FilterStringOption>;
    /** Filter based on GraphQL error code. */
    errorCode: Array<FilterStringOption>;
    httpHost: Array<FilterStringOption>;
    httpMethod: Array<FilterStringOption>;
    httpRoute: Array<FilterStringOption>;
    httpStatusCode: Array<FilterStringOption>;
    httpUrl: Array<FilterStringOption>;
    operationName: Array<FilterStringOption>;
    operationType: Array<FilterStringOption>;
    subgraphs: Array<FilterStringOption>;
    success: Array<FilterBooleanOption>;
};
export type TracesFilterOptionsClientNameArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsErrorCodeArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsHttpHostArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsHttpMethodArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsHttpRouteArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsHttpStatusCodeArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsHttpUrlArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsOperationNameArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesFilterOptionsSubgraphsArgs = {
    top?: InputMaybe<Scalars['Int']['input']>;
};
export type TracesSortInput = {
    direction: SortDirectionType;
    sort: TracesSortType;
};
export declare enum TracesSortType {
    Duration = "DURATION",
    Timestamp = "TIMESTAMP"
}
export type TrackSavedFilterViewInput = {
    id: Scalars['ID']['input'];
    target: TargetReferenceInput;
};
export type TrackSavedFilterViewOkPayload = {
    __typename?: 'TrackSavedFilterViewOkPayload';
    savedFilter: SavedFilter;
};
/** @oneOf */
export type TrackSavedFilterViewResult = {
    __typename?: 'TrackSavedFilterViewResult';
    error?: Maybe<SavedFilterError>;
    ok?: Maybe<TrackSavedFilterViewOkPayload>;
};
export type TypeAdded = {
    __typename?: 'TypeAdded';
    addedTypeKind: Scalars['String']['output'];
    addedTypeName: Scalars['String']['output'];
};
export type TypeDescriptionAdded = {
    __typename?: 'TypeDescriptionAdded';
    addedTypeDescription: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type TypeDescriptionChanged = {
    __typename?: 'TypeDescriptionChanged';
    newTypeDescription: Scalars['String']['output'];
    oldTypeDescription: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type TypeDescriptionRemoved = {
    __typename?: 'TypeDescriptionRemoved';
    removedTypeDescription: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type TypeKindChanged = {
    __typename?: 'TypeKindChanged';
    newTypeKind: Scalars['String']['output'];
    oldTypeKind: Scalars['String']['output'];
    typeName: Scalars['String']['output'];
};
export type TypeRemoved = {
    __typename?: 'TypeRemoved';
    removedTypeName: Scalars['String']['output'];
};
export type UnionMemberAdded = {
    __typename?: 'UnionMemberAdded';
    addedToNewType?: Maybe<Scalars['Boolean']['output']>;
    addedUnionMemberTypeName: Scalars['String']['output'];
    unionName: Scalars['String']['output'];
};
export type UnionMemberRemoved = {
    __typename?: 'UnionMemberRemoved';
    removedUnionMemberTypeName: Scalars['String']['output'];
    unionName: Scalars['String']['output'];
};
/** Explorer for navigating unused schema parts within the contextual provided period. */
export type UnusedSchemaExplorer = {
    __typename?: 'UnusedSchemaExplorer';
    /**
     * The affected unused types and their fields/values/members etc.
     *
     * The types within the result only contain unused fields/values/members, all other entities are excluded,
     * they are not a representation of the full GraphQL schema.
     */
    types: Array<GraphQlNamedType>;
};
export type UpdateBaseSchemaError = Error & {
    __typename?: 'UpdateBaseSchemaError';
    message: Scalars['String']['output'];
};
export type UpdateBaseSchemaInput = {
    newBase?: InputMaybe<Scalars['String']['input']>;
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
    targetSlug: Scalars['String']['input'];
};
export type UpdateBaseSchemaOk = {
    __typename?: 'UpdateBaseSchemaOk';
    updatedTarget: Target;
};
export type UpdateBaseSchemaResult = {
    __typename?: 'UpdateBaseSchemaResult';
    error?: Maybe<UpdateBaseSchemaError>;
    ok?: Maybe<UpdateBaseSchemaOk>;
};
export type UpdateDocumentCollectionInput = {
    collectionId: Scalars['ID']['input'];
    description?: InputMaybe<Scalars['String']['input']>;
    name: Scalars['String']['input'];
};
export type UpdateDocumentCollectionOperationInput = {
    collectionId: Scalars['ID']['input'];
    headers?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    operationId: Scalars['ID']['input'];
    query?: InputMaybe<Scalars['String']['input']>;
    variables?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateMeError = Error & {
    __typename?: 'UpdateMeError';
    /** The detailed validation error messages for the input fields. */
    inputErrors: UpdateMeInputErrors;
    message: Scalars['String']['output'];
};
export type UpdateMeInput = {
    displayName: Scalars['String']['input'];
    fullName: Scalars['String']['input'];
};
export type UpdateMeInputErrors = {
    __typename?: 'UpdateMeInputErrors';
    displayName?: Maybe<Scalars['String']['output']>;
    fullName?: Maybe<Scalars['String']['output']>;
};
export type UpdateMeOk = {
    __typename?: 'UpdateMeOk';
    updatedUser: User;
};
/** @oneOf */
export type UpdateMeResult = {
    __typename?: 'UpdateMeResult';
    error?: Maybe<UpdateMeError>;
    ok?: Maybe<UpdateMeOk>;
};
export type UpdateMemberRoleInput = {
    description: Scalars['String']['input'];
    /** The member role that should be udpated. */
    memberRole: MemberRoleReferenceInput;
    name: Scalars['String']['input'];
    selectedPermissions: Array<Scalars['String']['input']>;
};
export type UpdateMemberRoleInputErrors = {
    __typename?: 'UpdateMemberRoleInputErrors';
    description?: Maybe<Scalars['String']['output']>;
    name?: Maybe<Scalars['String']['output']>;
};
/** @oneOf */
export type UpdateMemberRoleResult = {
    __typename?: 'UpdateMemberRoleResult';
    error?: Maybe<UpdateMemberRoleResultError>;
    ok?: Maybe<UpdateMemberRoleResultOk>;
};
export type UpdateMemberRoleResultError = {
    __typename?: 'UpdateMemberRoleResultError';
    /** The detailed validation error messages for the input fields. */
    inputErrors?: Maybe<UpdateMemberRoleInputErrors>;
    message: Scalars['String']['output'];
};
export type UpdateMemberRoleResultOk = {
    __typename?: 'UpdateMemberRoleResultOk';
    updatedRole: MemberRole;
};
export type UpdateMetricAlertRuleError = Error & {
    __typename?: 'UpdateMetricAlertRuleError';
    message: Scalars['String']['output'];
};
export type UpdateMetricAlertRuleInput = {
    channelIds?: InputMaybe<Array<Scalars['ID']['input']>>;
    confirmationMinutes?: InputMaybe<Scalars['Int']['input']>;
    direction?: InputMaybe<MetricAlertRuleDirection>;
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    metric?: InputMaybe<MetricAlertRuleMetric>;
    name?: InputMaybe<Scalars['String']['input']>;
    project: ProjectReferenceInput;
    ruleId: Scalars['ID']['input'];
    savedFilterId?: InputMaybe<Scalars['ID']['input']>;
    severity?: InputMaybe<MetricAlertRuleSeverity>;
    thresholdType?: InputMaybe<MetricAlertRuleThresholdType>;
    thresholdValue?: InputMaybe<Scalars['Float']['input']>;
    timeWindowMinutes?: InputMaybe<Scalars['Int']['input']>;
    type?: InputMaybe<MetricAlertRuleType>;
};
export type UpdateMetricAlertRuleOk = {
    __typename?: 'UpdateMetricAlertRuleOk';
    updatedMetricAlertRule: MetricAlertRule;
};
export type UpdateMetricAlertRuleResult = {
    __typename?: 'UpdateMetricAlertRuleResult';
    error?: Maybe<UpdateMetricAlertRuleError>;
    ok?: Maybe<UpdateMetricAlertRuleOk>;
};
export type UpdateOidcDefaultMemberRoleError = Error & {
    __typename?: 'UpdateOIDCDefaultMemberRoleError';
    message: Scalars['String']['output'];
};
export type UpdateOidcDefaultMemberRoleInput = {
    defaultMemberRoleId: Scalars['ID']['input'];
    oidcIntegrationId: Scalars['ID']['input'];
};
export type UpdateOidcDefaultMemberRoleOk = {
    __typename?: 'UpdateOIDCDefaultMemberRoleOk';
    updatedOIDCIntegration: OidcIntegration;
};
/** @oneOf */
export type UpdateOidcDefaultMemberRoleResult = {
    __typename?: 'UpdateOIDCDefaultMemberRoleResult';
    error?: Maybe<UpdateOidcDefaultMemberRoleError>;
    ok?: Maybe<UpdateOidcDefaultMemberRoleOk>;
};
export type UpdateOidcDefaultResourceAssignmentError = Error & {
    __typename?: 'UpdateOIDCDefaultResourceAssignmentError';
    message: Scalars['String']['output'];
};
export type UpdateOidcDefaultResourceAssignmentInput = {
    oidcIntegrationId: Scalars['ID']['input'];
    resources: ResourceAssignmentInput;
};
export type UpdateOidcDefaultResourceAssignmentOk = {
    __typename?: 'UpdateOIDCDefaultResourceAssignmentOk';
    updatedOIDCIntegration: OidcIntegration;
};
/** @oneOf */
export type UpdateOidcDefaultResourceAssignmentResult = {
    __typename?: 'UpdateOIDCDefaultResourceAssignmentResult';
    error?: Maybe<UpdateOidcDefaultResourceAssignmentError>;
    ok?: Maybe<UpdateOidcDefaultResourceAssignmentOk>;
};
export type UpdateOidcIntegrationError = Error & {
    __typename?: 'UpdateOIDCIntegrationError';
    details: UpdateOidcIntegrationErrorDetails;
    message: Scalars['String']['output'];
};
export type UpdateOidcIntegrationErrorDetails = {
    __typename?: 'UpdateOIDCIntegrationErrorDetails';
    additionalScopes?: Maybe<Scalars['String']['output']>;
    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 UpdateOidcIntegrationInput = {
    additionalScopes?: InputMaybe<Array<Scalars['String']['input']>>;
    authorizationEndpoint?: InputMaybe<Scalars['String']['input']>;
    clientId?: InputMaybe<Scalars['ID']['input']>;
    clientSecret?: InputMaybe<Scalars['String']['input']>;
    oidcIntegrationId: Scalars['ID']['input'];
    tokenEndpoint?: InputMaybe<Scalars['String']['input']>;
    userinfoEndpoint?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateOidcIntegrationOk = {
    __typename?: 'UpdateOIDCIntegrationOk';
    updatedOIDCIntegration: OidcIntegration;
};
export type UpdateOidcIntegrationResult = {
    __typename?: 'UpdateOIDCIntegrationResult';
    error?: Maybe<UpdateOidcIntegrationError>;
    ok?: Maybe<UpdateOidcIntegrationOk>;
};
export type UpdateOidcRestrictionsError = Error & {
    __typename?: 'UpdateOIDCRestrictionsError';
    message: Scalars['String']['output'];
};
export type UpdateOidcRestrictionsInput = {
    oidcIntegrationId: Scalars['ID']['input'];
    oidcUserAccessOnly?: InputMaybe<Scalars['Boolean']['input']>;
    /**
     * Applies only to newly invited members.
     * Existing members are not affected.
     */
    oidcUserJoinOnly?: InputMaybe<Scalars['Boolean']['input']>;
    requireInvitation?: InputMaybe<Scalars['Boolean']['input']>;
};
export type UpdateOidcRestrictionsOk = {
    __typename?: 'UpdateOIDCRestrictionsOk';
    updatedOIDCIntegration: OidcIntegration;
};
/** @oneOf */
export type UpdateOidcRestrictionsResult = {
    __typename?: 'UpdateOIDCRestrictionsResult';
    error?: Maybe<UpdateOidcRestrictionsError>;
    ok?: Maybe<UpdateOidcRestrictionsOk>;
};
export type UpdateOrganizationSlugError = Error & {
    __typename?: 'UpdateOrganizationSlugError';
    message: Scalars['String']['output'];
};
export type UpdateOrganizationSlugInput = {
    organizationSlug: Scalars['String']['input'];
    slug: Scalars['String']['input'];
};
export type UpdateOrganizationSlugOk = {
    __typename?: 'UpdateOrganizationSlugOk';
    updatedOrganizationPayload: OrganizationPayload;
};
export type UpdateOrganizationSlugResult = {
    __typename?: 'UpdateOrganizationSlugResult';
    error?: Maybe<UpdateOrganizationSlugError>;
    ok?: Maybe<UpdateOrganizationSlugOk>;
};
export type UpdatePreflightScriptInput = {
    selector: TargetSelectorInput;
    sourceCode: Scalars['String']['input'];
};
export type UpdateProjectGitRepositoryError = Error & {
    __typename?: 'UpdateProjectGitRepositoryError';
    message: Scalars['String']['output'];
};
export type UpdateProjectGitRepositoryInput = {
    gitRepository?: InputMaybe<Scalars['String']['input']>;
    organizationSlug: Scalars['String']['input'];
    projectSlug: Scalars['String']['input'];
};
export type UpdateProjectGitRepositoryOk = {
    __typename?: 'UpdateProjectGitRepositoryOk';
    selector: ProjectSelector;
    updatedProject: Project;
};
export type UpdateProjectGitRepositoryResult = {
    __typename?: 'UpdateProjectGitRepositoryResult';
    error?: Maybe<UpdateProjectGitRepositoryError>;
    ok?: Maybe<UpdateProjectGitRepositoryOk>;
};
export type UpdateProjectPayload = {
    __typename?: 'UpdateProjectPayload';
    selector: ProjectSelector;
    updatedProject: Project;
};
export type UpdateProjectSlugError = {
    __typename?: 'UpdateProjectSlugError';
    message: Scalars['String']['output'];
};
export type UpdateProjectSlugInput = {
    project: ProjectReferenceInput;
    slug: Scalars['String']['input'];
};
export type UpdateProjectSlugOk = {
    __typename?: 'UpdateProjectSlugOk';
    updatedProject: Project;
};
export type UpdateProjectSlugResult = {
    __typename?: 'UpdateProjectSlugResult';
    error?: Maybe<UpdateProjectSlugError>;
    ok?: Maybe<UpdateProjectSlugOk>;
};
export type UpdateSavedFilterInput = {
    description?: InputMaybe<Scalars['String']['input']>;
    id: Scalars['ID']['input'];
    insightsFilter?: InputMaybe<InsightsFilterConfigurationInput>;
    name?: InputMaybe<Scalars['String']['input']>;
    target: TargetReferenceInput;
    visibility?: InputMaybe<SavedFilterVisibilityType>;
};
export type UpdateSavedFilterOkPayload = {
    __typename?: 'UpdateSavedFilterOkPayload';
    savedFilter: SavedFilter;
};
/** @oneOf */
export type UpdateSavedFilterResult = {
    __typename?: 'UpdateSavedFilterResult';
    error?: Maybe<SavedFilterError>;
    ok?: Maybe<UpdateSavedFilterOkPayload>;
};
export type UpdateSchemaCompositionError = {
    message: Scalars['String']['output'];
};
export type UpdateSchemaCompositionExternalError = UpdateSchemaCompositionError & {
    __typename?: 'UpdateSchemaCompositionExternalError';
    inputErrors?: Maybe<UpdateSchemaCompositionExternalInputErrors>;
    message: Scalars['String']['output'];
};
export type UpdateSchemaCompositionExternalInputErrors = {
    __typename?: 'UpdateSchemaCompositionExternalInputErrors';
    endpoint?: Maybe<Scalars['String']['output']>;
    secret?: Maybe<Scalars['String']['output']>;
};
export type UpdateSchemaCompositionInput = {
    /** The composition method that should be set for the project. */
    method: SchemaCompositionMethodInput;
    /** Reference to the project on which the schema composition should be applied. */
    project: ProjectReferenceInput;
};
export type UpdateSchemaCompositionLegacyError = UpdateSchemaCompositionError & {
    __typename?: 'UpdateSchemaCompositionLegacyError';
    message: Scalars['String']['output'];
};
export type UpdateSchemaCompositionNativeError = UpdateSchemaCompositionError & {
    __typename?: 'UpdateSchemaCompositionNativeError';
    message: Scalars['String']['output'];
};
/** @oneOf */
export type UpdateSchemaCompositionResult = {
    __typename?: 'UpdateSchemaCompositionResult';
    error?: Maybe<UpdateSchemaCompositionError>;
    ok?: Maybe<UpdateSchemaCompositionResultOk>;
};
export type UpdateSchemaCompositionResultOk = {
    __typename?: 'UpdateSchemaCompositionResultOk';
    updatedProject: Project;
};
export type UpdateSchemaPolicyResult = {
    __typename?: 'UpdateSchemaPolicyResult';
    error?: Maybe<Error>;
    ok?: Maybe<UpdateSchemaPolicyResultOk>;
};
export type UpdateSchemaPolicyResultError = Error & {
    __typename?: 'UpdateSchemaPolicyResultError';
    code?: Maybe<Scalars['String']['output']>;
    message: Scalars['String']['output'];
};
export type UpdateSchemaPolicyResultOk = {
    __typename?: 'UpdateSchemaPolicyResultOk';
    organization?: Maybe<Organization>;
    project?: Maybe<Project>;
    updatedPolicy: SchemaPolicy;
};
export type UpdateTargetAppDeploymentProtectionConfigurationInput = {
    /** Updates to the app deployment protection configuration. */
    appDeploymentProtectionConfiguration: AppDeploymentProtectionConfigurationInput;
    /** The target on which the settings are adjusted. */
    target: TargetReferenceInput;
};
export type UpdateTargetAppDeploymentProtectionConfigurationInputErrors = {
    __typename?: 'UpdateTargetAppDeploymentProtectionConfigurationInputErrors';
    maxTrafficPercentage?: Maybe<Scalars['String']['output']>;
    minDaysInactive?: Maybe<Scalars['String']['output']>;
    minDaysSinceCreation?: Maybe<Scalars['String']['output']>;
    trafficPeriodDays?: Maybe<Scalars['String']['output']>;
};
export type UpdateTargetAppDeploymentProtectionConfigurationResult = {
    __typename?: 'UpdateTargetAppDeploymentProtectionConfigurationResult';
    error?: Maybe<UpdateTargetAppDeploymentProtectionConfigurationResultError>;
    ok?: Maybe<UpdateTargetAppDeploymentProtectionConfigurationResultOk>;
};
export type UpdateTargetAppDeploymentProtectionConfigurationResultError = {
    __typename?: 'UpdateTargetAppDeploymentProtectionConfigurationResultError';
    inputErrors: UpdateTargetAppDeploymentProtectionConfigurationInputErrors;
    message: Scalars['String']['output'];
};
export type UpdateTargetAppDeploymentProtectionConfigurationResultOk = {
    __typename?: 'UpdateTargetAppDeploymentProtectionConfigurationResultOk';
    target: Target;
};
export type UpdateTargetConditionalBreakingChangeConfigurationInput = {
    /** Updates to the conditional breaking change configuration. */
    conditionalBreakingChangeConfiguration: ConditionalBreakingChangeConfigurationInput;
    /** The target on which the settings are adjusted. */
    target: TargetReferenceInput;
};
export type UpdateTargetConditionalBreakingChangeConfigurationInputErrors = {
    __typename?: 'UpdateTargetConditionalBreakingChangeConfigurationInputErrors';
    percentage?: Maybe<Scalars['String']['output']>;
    period?: Maybe<Scalars['String']['output']>;
    requestCount?: Maybe<Scalars['String']['output']>;
    targetIds?: Maybe<Scalars['String']['output']>;
};
export type UpdateTargetConditionalBreakingChangeConfigurationResult = {
    __typename?: 'UpdateTargetConditionalBreakingChangeConfigurationResult';
    error?: Maybe<UpdateTargetConditionalBreakingChangeConfigurationResultError>;
    ok?: Maybe<UpdateTargetConditionalBreakingChangeConfigurationResultOk>;
};
export type UpdateTargetConditionalBreakingChangeConfigurationResultError = {
    __typename?: 'UpdateTargetConditionalBreakingChangeConfigurationResultError';
    inputErrors: UpdateTargetConditionalBreakingChangeConfigurationInputErrors;
    message: Scalars['String']['output'];
};
export type UpdateTargetConditionalBreakingChangeConfigurationResultOk = {
    __typename?: 'UpdateTargetConditionalBreakingChangeConfigurationResultOk';
    target: Target;
};
export type UpdateTargetDangerousChangeClassificationInput = {
    failDiffOnDangerousChange: Scalars['Boolean']['input'];
    target: TargetReferenceInput;
};
export type UpdateTargetDangerousChangeClassificationResult = {
    __typename?: 'UpdateTargetDangerousChangeClassificationResult';
    error?: Maybe<UpdateTargetDangerousChangeClassificationResultError>;
    ok?: Maybe<UpdateTargetDangerousChangeClassificationResultOk>;
};
export type UpdateTargetDangerousChangeClassificationResultError = {
    __typename?: 'UpdateTargetDangerousChangeClassificationResultError';
    message: Scalars['String']['output'];
};
export type UpdateTargetDangerousChangeClassificationResultOk = {
    __typename?: 'UpdateTargetDangerousChangeClassificationResultOk';
    target: Target;
};
export type UpdateTargetGraphQlEndpointUrlInput = {
    graphqlEndpointUrl?: InputMaybe<Scalars['String']['input']>;
    target: TargetReferenceInput;
};
export type UpdateTargetGraphQlEndpointUrlResult = {
    __typename?: 'UpdateTargetGraphQLEndpointUrlResult';
    error?: Maybe<UpdateTargetGraphQlEndpointUrlResultError>;
    ok?: Maybe<UpdateTargetGraphQlEndpointUrlResultOk>;
};
export type UpdateTargetGraphQlEndpointUrlResultError = {
    __typename?: 'UpdateTargetGraphQLEndpointUrlResultError';
    message: Scalars['String']['output'];
};
export type UpdateTargetGraphQlEndpointUrlResultOk = {
    __typename?: 'UpdateTargetGraphQLEndpointUrlResultOk';
    target: Target;
};
export type UpdateTargetSlugInput = {
    slug: Scalars['String']['input'];
    target: TargetReferenceInput;
};
export type UpdateTargetSlugResult = {
    __typename?: 'UpdateTargetSlugResult';
    error?: Maybe<UpdateTargetSlugResultError>;
    ok?: Maybe<UpdateTargetSlugResultOk>;
};
export type UpdateTargetSlugResultError = {
    __typename?: 'UpdateTargetSlugResultError';
    message: Scalars['String']['output'];
};
export type UpdateTargetSlugResultOk = {
    __typename?: 'UpdateTargetSlugResultOk';
    selector: TargetSelector;
    target: Target;
};
export type UpgradeToProInput = {
    couponCode?: InputMaybe<Scalars['String']['input']>;
    monthlyLimits: RateLimitInput;
    organization: OrganizationSelectorInput;
    paymentMethodId?: InputMaybe<Scalars['String']['input']>;
};
export type UsageEstimation = {
    __typename?: 'UsageEstimation';
    /** The estimated number of operations used for the month. */
    operations: Scalars['SafeInt']['output'];
};
export type UsageEstimationInput = {
    month: Scalars['Int']['input'];
    organizationSlug: Scalars['String']['input'];
    year: Scalars['Int']['input'];
};
export declare enum UsageRateLimitType {
    MonthlyLimited = "MONTHLY_LIMITED",
    MonthlyQuota = "MONTHLY_QUOTA",
    Unlimited = "UNLIMITED"
}
export type User = {
    __typename?: 'User';
    canSwitchOrganization: Scalars['Boolean']['output'];
    displayName: Scalars['String']['output'];
    email: Scalars['String']['output'];
    fullName: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    isAdmin: Scalars['Boolean']['output'];
    provider: AuthProviderType;
    providers: Array<AuthProviderType>;
};
export type UserConnection = {
    __typename?: 'UserConnection';
    nodes: Array<User>;
    total: Scalars['Int']['output'];
};
export type VerifyEmailError = Error & {
    __typename?: 'VerifyEmailError';
    message: Scalars['String']['output'];
};
export type VerifyEmailInput = {
    email: Scalars['String']['input'];
    token: Scalars['String']['input'];
    userIdentityId: Scalars['ID']['input'];
};
export type VerifyEmailOk = {
    __typename?: 'VerifyEmailOk';
    verified: Scalars['Boolean']['output'];
};
/** @oneOf */
export type VerifyEmailResult = {
    __typename?: 'VerifyEmailResult';
    error?: Maybe<VerifyEmailError>;
    ok?: Maybe<VerifyEmailOk>;
};
export type VerifyOidcDomainChallengeError = {
    __typename?: 'VerifyOIDCDomainChallengeError';
    message: Scalars['String']['output'];
};
export type VerifyOidcDomainChallengeInput = {
    oidcDomainId: Scalars['ID']['input'];
};
export type VerifyOidcDomainChallengeOk = {
    __typename?: 'VerifyOIDCDomainChallengeOk';
    verifiedOIDCIntegrationDomain: OidcIntegrationDomain;
};
export type VerifyOidcDomainChallengeResult = {
    __typename?: 'VerifyOIDCDomainChallengeResult';
    error?: Maybe<VerifyOidcDomainChallengeError>;
    ok?: Maybe<VerifyOidcDomainChallengeOk>;
};
export type WebhookChannelInput = {
    endpoint: Scalars['String']['input'];
};
/**
 * Represents the currently authorized actor (user, service, etc.)
 * and its associated permissions.
 */
export type WhoAmI = {
    __typename?: 'WhoAmI';
    /**
     * A structured view of permissions that the authorized actor can perform,
     * optionally including all possible permissions for context.
     */
    resolvedPermissions: Array<ResolvedResourcePermissionGroup>;
    /**
     * Human-readable title identifying the type of actor
     * (e.g., "User", "Access Token").
     */
    title: Scalars['String']['output'];
};
/**
 * Represents the currently authorized actor (user, service, etc.)
 * and its associated permissions.
 */
export type WhoAmIResolvedPermissionsArgs = {
    includeAll?: Scalars['Boolean']['input'];
};
export type CreateAppDeploymentMutationVariables = Exact<{
    input: CreateAppDeploymentInput;
}>;
export type CreateAppDeploymentMutation = {
    __typename?: 'Mutation';
    createAppDeployment: {
        __typename?: 'CreateAppDeploymentResult';
        ok?: {
            __typename?: 'CreateAppDeploymentOk';
            createdAppDeployment: {
                __typename?: 'AppDeployment';
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error?: {
            __typename?: 'CreateAppDeploymentError';
            message: string;
        } | null;
    };
};
export type AddDocumentsToAppDeploymentMutationVariables = Exact<{
    input: AddDocumentsToAppDeploymentInput;
}>;
export type AddDocumentsToAppDeploymentMutation = {
    __typename?: 'Mutation';
    addDocumentsToAppDeployment: {
        __typename?: 'AddDocumentsToAppDeploymentResult';
        ok?: {
            __typename?: 'AddDocumentsToAppDeploymentOk';
            appDeployment: {
                __typename?: 'AppDeployment';
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error?: {
            __typename?: 'AddDocumentsToAppDeploymentError';
            message: string;
            details?: {
                __typename: 'AddDocumentsToAppDeploymentErrorDetails';
                index: number;
                message: string;
            } | null;
        } | null;
    };
};
export type ActivateAppDeploymentMutationVariables = Exact<{
    input: ActivateAppDeploymentInput;
}>;
export type ActivateAppDeploymentMutation = {
    __typename?: 'Mutation';
    activateAppDeployment: {
        __typename?: 'ActivateAppDeploymentResult';
        ok?: {
            __typename?: 'ActivateAppDeploymentOk';
            isSkipped: boolean;
            activatedAppDeployment: {
                __typename?: 'AppDeployment';
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error?: {
            __typename?: 'ActivateAppDeploymentError';
            message: string;
        } | null;
    };
};
export type RetireAppDeploymentMutationVariables = Exact<{
    input: RetireAppDeploymentInput;
}>;
export type RetireAppDeploymentMutation = {
    __typename?: 'Mutation';
    retireAppDeployment: {
        __typename?: 'RetireAppDeploymentResult';
        ok?: {
            __typename?: 'RetireAppDeploymentOk';
            retiredAppDeployment: {
                __typename?: 'AppDeployment';
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error?: {
            __typename?: 'RetireAppDeploymentError';
            message: string;
            protectionDetails?: {
                __typename?: 'AppDeploymentProtectionBlockDetails';
                lastUsed?: any | null;
                daysSinceLastUsed?: number | null;
                requiredMinDaysInactive: number;
                currentTrafficPercentage?: number | null;
                maxTrafficPercentage: number;
            } | null;
        } | null;
    };
};
export type Cli_SchemaComposeMutationMutationVariables = Exact<{
    input: SchemaComposeInput;
}>;
export type Cli_SchemaComposeMutationMutation = {
    __typename?: 'Mutation';
    schemaCompose: {
        __typename: 'SchemaComposeError';
        message: string;
    } | {
        __typename: 'SchemaComposeSuccess';
        valid: boolean;
        compositionResult: {
            __typename?: 'SchemaCompositionResult';
            supergraphSdl?: string | null;
            errors?: ({
                __typename?: 'SchemaErrorConnection';
            } & {
                ' $fragmentRefs'?: {
                    'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
                };
            }) | null;
        };
    };
};
export type FetchLatestVersionQueryVariables = Exact<{
    target?: InputMaybe<TargetReferenceInput>;
}>;
export type FetchLatestVersionQuery = {
    __typename?: 'Query';
    latestValidVersion?: {
        __typename?: 'SchemaVersion';
        sdl?: string | null;
    } | null;
};
export type ApproveFailedSchemaCheckMutationVariables = Exact<{
    input: ApproveFailedSchemaCheckInput;
}>;
export type ApproveFailedSchemaCheckMutation = {
    __typename?: 'Mutation';
    approveFailedSchemaCheck: {
        __typename?: 'ApproveFailedSchemaCheckResult';
        ok?: {
            __typename?: 'ApproveFailedSchemaCheckOk';
            schemaCheck: {
                __typename?: 'FailedSchemaCheck';
                id: string;
            } | {
                __typename?: 'SuccessfulSchemaCheck';
                id: string;
            };
        } | null;
        error?: {
            __typename?: 'ApproveFailedSchemaCheckError';
            message: string;
        } | null;
    };
};
export type SchemaCheckMutationVariables = Exact<{
    input: SchemaCheckInput;
}>;
export type SchemaCheckMutation = {
    __typename?: 'Mutation';
    schemaCheck: {
        __typename: 'GitHubSchemaCheckError';
        message: string;
    } | {
        __typename: 'GitHubSchemaCheckSuccess';
        message: string;
    } | {
        __typename: 'SchemaCheckError';
        valid: boolean;
        changes?: ({
            __typename?: 'SchemaChangeConnection';
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        warnings?: {
            __typename?: 'SchemaWarningConnection';
            total: number;
            nodes: Array<{
                __typename?: 'SchemaCheckWarning';
                message: string;
                source?: string | null;
                line?: number | null;
                column?: number | null;
            }>;
        } | null;
        errors: ({
            __typename?: 'SchemaErrorConnection';
        } & {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        });
        schemaCheck?: {
            __typename?: 'FailedSchemaCheck';
            id: string;
            webUrl?: string | null;
        } | {
            __typename?: 'SuccessfulSchemaCheck';
            id: string;
            webUrl?: string | null;
        } | null;
    } | {
        __typename: 'SchemaCheckSuccess';
        valid: boolean;
        initial: boolean;
        warnings?: {
            __typename?: 'SchemaWarningConnection';
            total: number;
            nodes: Array<{
                __typename?: 'SchemaCheckWarning';
                message: string;
                source?: string | null;
                line?: number | null;
                column?: number | null;
            }>;
        } | null;
        changes?: ({
            __typename?: 'SchemaChangeConnection';
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        schemaCheck?: {
            __typename?: 'FailedSchemaCheck';
            id: string;
            webUrl?: string | null;
        } | {
            __typename?: 'SuccessfulSchemaCheck';
            id: string;
            webUrl?: string | null;
        } | null;
    };
};
export type SchemaDeleteMutationVariables = Exact<{
    input: SchemaDeleteInput;
}>;
export type SchemaDeleteMutation = {
    __typename?: 'Mutation';
    schemaDelete: {
        __typename: 'SchemaDeleteError';
        valid: boolean;
        errors: ({
            __typename?: 'SchemaErrorConnection';
        } & {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        });
    } | {
        __typename: 'SchemaDeleteSuccess';
        valid: boolean;
        errors: ({
            __typename?: 'SchemaErrorConnection';
        } & {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        });
    };
};
export type SchemaVersionByCommitQueryVariables = Exact<{
    commit: Scalars['String']['input'];
    includeSDL: Scalars['Boolean']['input'];
    includeSupergraph: Scalars['Boolean']['input'];
    includeSubgraphs: Scalars['Boolean']['input'];
    target?: InputMaybe<TargetReferenceInput>;
}>;
export type SchemaVersionByCommitQuery = {
    __typename?: 'Query';
    schemaVersionByCommit?: {
        __typename?: 'SchemaVersion';
        id: string;
        isValid: boolean;
        sdl?: string | null;
        supergraph?: string | null;
        schemas?: {
            __typename?: 'SchemaConnection';
            edges: Array<{
                __typename?: 'SchemaEdge';
                node: {
                    __typename: 'CompositeSchema';
                    id: string;
                    date: any;
                    url?: string | null;
                    service?: string | null;
                } | {
                    __typename: 'SingleSchema';
                    id: string;
                    date: any;
                };
            }>;
        };
    } | null;
};
export type LatestSchemaVersionQueryVariables = Exact<{
    includeSDL: Scalars['Boolean']['input'];
    includeSupergraph: Scalars['Boolean']['input'];
    includeSubgraphs: Scalars['Boolean']['input'];
    target?: InputMaybe<TargetReferenceInput>;
}>;
export type LatestSchemaVersionQuery = {
    __typename?: 'Query';
    latestValidVersion?: {
        __typename?: 'SchemaVersion';
        id: string;
        isValid: boolean;
        sdl?: string | null;
        supergraph?: string | null;
        schemas?: {
            __typename?: 'SchemaConnection';
            edges: Array<{
                __typename?: 'SchemaEdge';
                node: {
                    __typename: 'CompositeSchema';
                    id: string;
                    date: any;
                    url?: string | null;
                    service?: string | null;
                } | {
                    __typename: 'SingleSchema';
                    id: string;
                    date: any;
                };
            }>;
        };
    } | null;
};
export type Cli_SchemaVersionPromoteMutationMutationVariables = Exact<{
    input: SchemaVersionPromoteInput;
}>;
export type Cli_SchemaVersionPromoteMutationMutation = {
    __typename?: 'Mutation';
    schemaVersionPromote: {
        __typename?: 'SchemaVersionPromoteResult';
        ok?: {
            __typename?: 'SchemaVersionPromoteResultOk';
            linkToWebsite?: string | null;
            newSchemaVersion: {
                __typename?: 'SchemaVersion';
                id: string;
            };
        } | null;
        error?: {
            __typename?: 'SchemaVersionPromoteResultError';
            message: string;
        } | null;
    };
};
export type SchemaPublishMutationVariables = Exact<{
    input: SchemaPublishInput;
    usesGitHubApp: Scalars['Boolean']['input'];
}>;
export type SchemaPublishMutation = {
    __typename?: 'Mutation';
    schemaPublish: {
        __typename: 'GitHubSchemaPublishError';
        message: string;
    } | {
        __typename: 'GitHubSchemaPublishSuccess';
        message: string;
    } | {
        __typename: 'SchemaPublishError';
        valid: boolean;
        linkToWebsite?: string | null;
        changes?: ({
            __typename?: 'SchemaChangeConnection';
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        errors: ({
            __typename?: 'SchemaErrorConnection';
        } & {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        });
    } | {
        __typename: 'SchemaPublishMissingServiceError';
        missingServiceError: string;
    } | {
        __typename: 'SchemaPublishMissingUrlError';
        missingUrlError: string;
    } | {
        __typename: 'SchemaPublishRetry';
        reason: string;
    } | {
        __typename: 'SchemaPublishSuccess';
        initial: boolean;
        valid: boolean;
        linkToWebsite?: string | null;
        successMessage?: string | null;
        changes?: ({
            __typename?: 'SchemaChangeConnection';
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
    };
};
export type MyTokenInfoQueryVariables = Exact<{
    showAll: Scalars['Boolean']['input'];
}>;
export type MyTokenInfoQuery = {
    __typename?: 'Query';
    whoAmI?: {
        __typename?: 'WhoAmI';
        title: string;
        resolvedPermissions: Array<{
            __typename?: 'ResolvedResourcePermissionGroup';
            level: PermissionLevelType;
            resolvedResourceIds?: Array<string> | null;
            title: string;
            resolvedPermissionGroups: Array<{
                __typename?: 'ResolvedPermissionsGroup';
                title: string;
                permissions: Array<{
                    __typename?: 'ResolvedPermission';
                    isGranted: boolean;
                    permission: {
                        __typename?: 'Permission';
                        id: string;
                        title: string;
                        description: string;
                    };
                }>;
            }>;
        }>;
    } | null;
};
export type RenderErrors_SchemaErrorConnectionFragmentFragment = {
    __typename?: 'SchemaErrorConnection';
    edges: Array<{
        __typename?: 'SchemaErrorEdge';
        node: {
            __typename?: 'SchemaError';
            message: string;
        };
    }>;
} & {
    ' $fragmentName'?: 'RenderErrors_SchemaErrorConnectionFragmentFragment';
};
export type RenderChanges_SchemaChangesFragment = {
    __typename?: 'SchemaChangeConnection';
    edges: Array<{
        __typename?: 'SchemaChangeEdge';
        node: {
            __typename?: 'SchemaChange';
            severityLevel: SeverityLevelType;
            isSafeBasedOnUsage: boolean;
            message: string;
            approval?: {
                __typename?: 'SchemaChangeApproval';
                approvedBy?: {
                    __typename?: 'User';
                    displayName: string;
                } | null;
            } | null;
            affectedAppDeployments?: {
                __typename?: 'SchemaChangeAffectedAppDeploymentsConnection';
                totalCount: number;
            } | null;
        };
    }>;
} & {
    ' $fragmentName'?: 'RenderChanges_SchemaChangesFragment';
};
export declare const RenderErrors_SchemaErrorConnectionFragmentFragmentDoc: DocumentNode<RenderErrors_SchemaErrorConnectionFragmentFragment, unknown>;
export declare const RenderChanges_SchemaChangesFragmentDoc: DocumentNode<RenderChanges_SchemaChangesFragment, unknown>;
export declare const CreateAppDeploymentDocument: DocumentNode<CreateAppDeploymentMutation, CreateAppDeploymentMutationVariables>;
export declare const AddDocumentsToAppDeploymentDocument: DocumentNode<AddDocumentsToAppDeploymentMutation, AddDocumentsToAppDeploymentMutationVariables>;
export declare const ActivateAppDeploymentDocument: DocumentNode<ActivateAppDeploymentMutation, ActivateAppDeploymentMutationVariables>;
export declare const RetireAppDeploymentDocument: DocumentNode<RetireAppDeploymentMutation, RetireAppDeploymentMutationVariables>;
export declare const Cli_SchemaComposeMutationDocument: DocumentNode<Cli_SchemaComposeMutationMutation, Cli_SchemaComposeMutationMutationVariables>;
export declare const FetchLatestVersionDocument: DocumentNode<FetchLatestVersionQuery, FetchLatestVersionQueryVariables>;
export declare const ApproveFailedSchemaCheckDocument: DocumentNode<ApproveFailedSchemaCheckMutation, ApproveFailedSchemaCheckMutationVariables>;
export declare const SchemaCheckDocument: DocumentNode<SchemaCheckMutation, SchemaCheckMutationVariables>;
export declare const SchemaDeleteDocument: DocumentNode<SchemaDeleteMutation, SchemaDeleteMutationVariables>;
export declare const SchemaVersionByCommitDocument: DocumentNode<SchemaVersionByCommitQuery, SchemaVersionByCommitQueryVariables>;
export declare const LatestSchemaVersionDocument: DocumentNode<LatestSchemaVersionQuery, LatestSchemaVersionQueryVariables>;
export declare const Cli_SchemaVersionPromoteMutationDocument: DocumentNode<Cli_SchemaVersionPromoteMutationMutation, Cli_SchemaVersionPromoteMutationMutationVariables>;
export declare const SchemaPublishDocument: DocumentNode<SchemaPublishMutation, SchemaPublishMutationVariables>;
export declare const MyTokenInfoDocument: DocumentNode<MyTokenInfoQuery, MyTokenInfoQueryVariables>;
//# sourceMappingURL=graphql.d.ts.map