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

A CLI util to manage and control your GraphQL Hive

import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = T | null | undefined;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    Date: {
        input: any;
        output: any;
    };
    /**
     * A date-time string at UTC, such as '2007-12-03T10:15:30Z', is compliant with the date-time format outlined
     * in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.
     *
     * This scalar is a description of an exact instant on the timeline such as the instant that a user account was created.
     *
     * This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
     *
     * Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20+01:00' is shifted to '2016-01-01T13:10:20Z'.
     */
    DateTime: {
        input: any;
        output: any;
    };
    /**
     * A date-time string at UTC with nano-second precision, such as '2007-12-03T10:15:30.123456Z', is compliant with the extended date-time format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. The fractional part of the seconds can range up to nanosecond precision.
     *
     * This scalar represents an exact instant on the timeline, such as the precise moment a user account was created, including fractional seconds.
     *
     * This scalar ignores leap seconds (thereby assuming that a minute constitutes 59 seconds). In this respect, it diverges from the RFC 3339 profile.
     *
     * Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string '2016-01-01T14:10:20.500+01:00' is shifted to '2016-01-01T13:10:20.500Z'.
     */
    DateTime64: {
        input: any;
        output: any;
    };
    JSON: {
        input: any;
        output: any;
    };
    JSONObject: {
        input: any;
        output: any;
    };
    JSONSchemaObject: {
        input: any;
        output: any;
    };
    SafeInt: {
        input: any;
        output: any;
    };
};
/** Interface representing a generic access token. */
export type AccessToken = {
    /** Timestamp indicating when the access token was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional description providing additional context about the access token. */
    description?: Maybe<Scalars['String']['output']>;
    /** 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['