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

A CLI util to manage and control your GraphQL Hive

/** Internal type. DO NOT USE DIRECTLY. */
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
/** Internal type. DO NOT USE DIRECTLY. */
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type ActivateAppDeploymentInput = {
    appName: string;
    appVersion: string;
    target?: TargetReferenceInput | null | undefined;
};
export type AddDocumentsToAppDeploymentInput = {
    /** Name of the app. */
    appName: string;
    /** The version of the app */
    appVersion: string;
    /** A list of operations to add to the app deployment. (max 100 per single batch) */
    documents: Array<DocumentInput>;
    target?: TargetReferenceInput | null | undefined;
};
export declare enum AppDeploymentStatus {
    Active = "active",
    Pending = "pending",
    Retired = "retired"
}
export type ApproveFailedSchemaCheckInput = {
    author?: string | null | undefined;
    /**
     * Optional comment visible in the schema check.
     * Give a reason why the schema check was approved.
     */
    comment?: string | null | undefined;
    organizationSlug: string;
    projectSlug: string;
    schemaCheckId: string | number;
    targetSlug: string;
};
export type CreateAppDeploymentInput = {
    appName: string;
    appVersion: string;
    target?: TargetReferenceInput | null | undefined;
};
export type DocumentInput = {
    /** GraphQL operation body. */
    body: string;
    /** GraphQL operation hash. */
    hash: string;
};
export type GitHubSchemaCheckInput = {
    commit: string;
    /** The pull request number of the schema check. */
    pullRequestNumber?: string | null | undefined;
    /** The repository name of the schema check. */
    repository?: string | null | undefined;
};
export declare enum PermissionLevelType {
    AppDeployment = "APP_DEPLOYMENT",
    Organization = "ORGANIZATION",
    Project = "PROJECT",
    Service = "SERVICE",
    Target = "TARGET"
}
export type RetireAppDeploymentInput = {
    /** The identifying application name */
    appName: string;
    /** The exact version of the application to retire */
    appVersion: string;
    /** Force retirement even if protection rules would prevent it. Disabled by default. */
    force?: boolean;
    /**
     * 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?: TargetReferenceInput | null | undefined;
};
export type SchemaCheckBaselineInput = {
    /** An identifier for the supplied baseline schema, e.g. a Git SHA */
    hash?: string | null | undefined;
    /** The service schema SDL. */
    sdl: string;
};
export type SchemaCheckInput = {
    /**
     * The baseline service SDL before applying the proposed changes.
     *
     * When provided for a distributed schema, Hive composes this service SDL
     * with the other services currently stored in the registry and compares
     * that composition against the composition produced from 'SchemaCheckInput.sdl'.
     *
     * Intended for checks where the comparison baseline differs from the
     * latest schema stored in the registry, such as GitHub Merge Queue builds.
     */
    baseline?: SchemaCheckBaselineInput | null | undefined;
    /**
     * Optional context ID to group schema checks together.
     * Manually approved breaking changes will be memorized for schema checks with the same context id.
     */
    contextId?: string | null | undefined;
    github?: GitHubSchemaCheckInput | null | undefined;
    meta?: SchemaCheckMetaInput | null | undefined;
    /** Optional. Attaches the check to a schema proposal. */
    schemaProposalId?: string | number | null | undefined;
    /** The schema SDL after applying the proposed change. */
    sdl: string;
    service?: string | number | null | undefined;
    target?: TargetReferenceInput | null | undefined;
    /** Optional url if wanting to show subgraph url changes inside checks. */
    url?: string | null | undefined;
};
export type SchemaCheckMetaInput = {
    author: string;
    commit: string;
};
export type SchemaComposeInput = {
    services: Array<SchemaComposeServiceInput>;
    target?: TargetReferenceInput | null | undefined;
    /**
     * 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?: boolean | null | undefined;
};
export type SchemaComposeServiceInput = {
    name: string;
    sdl: string;
    url?: string | null | undefined;
};
export type SchemaDeleteInput = {
    dryRun?: boolean | null | undefined;
    serviceName: string | number;
    /** Whether the client supports retries in case the registry is busy and the operation could not be performed. */
    supportsRetry?: boolean | null | undefined;
    target?: TargetReferenceInput | null | undefined;
};
export type SchemaPublishGitHubInput = {
    /** The commit sha. */
    commit: string;
    /** The repository name. */
    repository: string;
};
export type SchemaPublishInput = {
    author: string;
    commit: string;
    /**
     * Accept breaking changes and mark schema as valid (if composable)
     * @deprecated Enabled by default for newly created projects
     */
    experimental_acceptBreakingChanges?: boolean | null | undefined;
    /** @deprecated Enabled by default for newly created projects */
    force?: boolean | null | undefined;
    /** Link GitHub version to a GitHub commit on a repository. */
    gitHub?: SchemaPublishGitHubInput | null | undefined;
    /**
     * Talk to GitHub Application and create a check-run
     * @deprecated Use SchemaPublishInput.gitHub instead.
     */
    github?: boolean | null | undefined;
    metadata?: string | null | undefined;
    sdl: string;
    service?: string | number | null | undefined;
    /** Whether the CLI supports retrying the schema publish, in case acquiring the schema publish lock fails due to a busy queue. */
    supportsRetry?: boolean | null | undefined;
    target?: TargetReferenceInput | null | undefined;
    url?: string | null | undefined;
};
/**
 * 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 SchemaVersionPromoteSourceInput = {
    fromSchemaVersionById: string | number;
    fromTarget?: never;
} | {
    fromSchemaVersionById?: never; /** The latest version within the target should be promoted. */
    fromTarget: TargetReferenceInput;
};
export type SchemaVersionPromoteTargetInput = {
    toTarget: TargetReferenceInput;
};
/** 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"
}
/** Reference to a target. */
export type TargetReferenceInput = {
    byId: string | number;
    bySelector?: never;
} | {
    byId?: never; /** Reference to a target using it's slug parts (see "Organization.slug", "Project.slug", "Target.slug"). */
    bySelector: TargetSelectorInput;
};
export type TargetSelectorInput = {
    organizationSlug: string;
    projectSlug: string;
    targetSlug: string;
};
export type CreateAppDeploymentMutationVariables = Exact<{
    input: CreateAppDeploymentInput;
}>;
export type CreateAppDeploymentMutation = {
    createAppDeployment: {
        ok: {
            createdAppDeployment: {
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error: {
            message: string;
        } | null;
    };
};
export type AddDocumentsToAppDeploymentMutationVariables = Exact<{
    input: AddDocumentsToAppDeploymentInput;
}>;
export type AddDocumentsToAppDeploymentMutation = {
    addDocumentsToAppDeployment: {
        ok: {
            appDeployment: {
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error: {
            message: string;
            details: {
                __typename: 'AddDocumentsToAppDeploymentErrorDetails';
                index: number;
                message: string;
            } | null;
        } | null;
    };
};
export type ActivateAppDeploymentMutationVariables = Exact<{
    input: ActivateAppDeploymentInput;
}>;
export type ActivateAppDeploymentMutation = {
    activateAppDeployment: {
        ok: {
            isSkipped: boolean;
            activatedAppDeployment: {
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error: {
            message: string;
        } | null;
    };
};
export type RetireAppDeploymentMutationVariables = Exact<{
    input: RetireAppDeploymentInput;
}>;
export type RetireAppDeploymentMutation = {
    retireAppDeployment: {
        ok: {
            retiredAppDeployment: {
                id: string;
                name: string;
                version: string;
                status: AppDeploymentStatus;
            };
        } | null;
        error: {
            message: string;
            protectionDetails: {
                lastUsed: unknown;
                daysSinceLastUsed: number | null;
                requiredMinDaysInactive: number;
                currentTrafficPercentage: number | null;
                maxTrafficPercentage: number;
            } | null;
        } | null;
    };
};
export type Cli_SchemaComposeMutationMutationVariables = Exact<{
    input: SchemaComposeInput;
}>;
export type Cli_SchemaComposeMutationMutation = {
    schemaCompose: {
        __typename: 'SchemaComposeError';
        message: string;
    } | {
        __typename: 'SchemaComposeSuccess';
        valid: boolean;
        compositionResult: {
            supergraphSdl: string | null;
            errors: {
                ' $fragmentRefs'?: {
                    'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
                };
            } | null;
        };
    };
};
export type FetchLatestVersionQueryVariables = Exact<{
    target?: TargetReferenceInput | null | undefined;
}>;
export type FetchLatestVersionQuery = {
    latestValidVersion: {
        sdl: string | null;
    } | null;
};
export type ApproveFailedSchemaCheckMutationVariables = Exact<{
    input: ApproveFailedSchemaCheckInput;
}>;
export type ApproveFailedSchemaCheckMutation = {
    approveFailedSchemaCheck: {
        ok: {
            schemaCheck: {
                id: string;
            } | {
                id: string;
            };
        } | null;
        error: {
            message: string;
        } | null;
    };
};
export type Cli_SchemaCheckMutationMutationVariables = Exact<{
    input: SchemaCheckInput;
}>;
export type Cli_SchemaCheckMutationMutation = {
    schemaCheck: {
        __typename: 'GitHubSchemaCheckError';
        message: string;
    } | {
        __typename: 'GitHubSchemaCheckSuccess';
        message: string;
    } | {
        __typename: 'SchemaCheckError';
        valid: boolean;
        changes: ({
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        warnings: {
            total: number;
            nodes: Array<{
                message: string;
                source: string | null;
                line: number | null;
                column: number | null;
            }>;
        } | null;
        errors: {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        };
        schemaCheck: {
            id: string;
            webUrl: string | null;
        } | {
            id: string;
            webUrl: string | null;
        } | null;
    } | {
        __typename: 'SchemaCheckSuccess';
        valid: boolean;
        initial: boolean;
        warnings: {
            total: number;
            nodes: Array<{
                message: string;
                source: string | null;
                line: number | null;
                column: number | null;
            }>;
        } | null;
        changes: ({
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        schemaCheck: {
            id: string;
            webUrl: string | null;
        } | {
            id: string;
            webUrl: string | null;
        } | null;
    };
};
export type SchemaDeleteMutationVariables = Exact<{
    input: SchemaDeleteInput;
}>;
export type SchemaDeleteMutation = {
    schemaDelete: {
        __typename: 'SchemaDeleteError';
        valid: boolean;
        errors: {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        };
    } | {
        __typename: 'SchemaDeleteRetry';
        reason: string;
    } | {
        __typename: 'SchemaDeleteSuccess';
        valid: boolean;
        changes: {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        } | null;
        errors: {
            ' $fragmentRefs'?: {
                'RenderErrors_SchemaErrorConnectionFragmentFragment': RenderErrors_SchemaErrorConnectionFragmentFragment;
            };
        };
    };
};
export type SchemaVersionByCommitQueryVariables = Exact<{
    commit: string;
    includeSDL: boolean;
    includeSupergraph: boolean;
    includeSubgraphs: boolean;
    target?: TargetReferenceInput | null | undefined;
}>;
export type SchemaVersionByCommitQuery = {
    schemaVersionByCommit: {
        id: string;
        isValid: boolean;
        sdl?: string | null;
        supergraph?: string | null;
        schemas?: {
            edges: Array<{
                node: {
                    __typename: 'CompositeSchema';
                    id: string;
                    date: unknown;
                    url: string | null;
                    service: string | null;
                } | {
                    __typename: 'SingleSchema';
                    id: string;
                    date: unknown;
                };
            }>;
        };
    } | null;
};
export type LatestSchemaVersionQueryVariables = Exact<{
    includeSDL: boolean;
    includeSupergraph: boolean;
    includeSubgraphs: boolean;
    target?: TargetReferenceInput | null | undefined;
}>;
export type LatestSchemaVersionQuery = {
    latestValidVersion: {
        id: string;
        isValid: boolean;
        sdl?: string | null;
        supergraph?: string | null;
        schemas?: {
            edges: Array<{
                node: {
                    __typename: 'CompositeSchema';
                    id: string;
                    date: unknown;
                    url: string | null;
                    service: string | null;
                } | {
                    __typename: 'SingleSchema';
                    id: string;
                    date: unknown;
                };
            }>;
        };
    } | null;
};
export type Cli_SchemaVersionPromoteMutationMutationVariables = Exact<{
    input: SchemaVersionPromoteInput;
}>;
export type Cli_SchemaVersionPromoteMutationMutation = {
    schemaVersionPromote: {
        ok: {
            linkToWebsite: string | null;
            newSchemaVersion: {
                id: string;
            };
        } | null;
        error: {
            message: string;
        } | null;
    };
};
export type SchemaPublishMutationVariables = Exact<{
    input: SchemaPublishInput;
    usesGitHubApp: boolean;
}>;
export type SchemaPublishMutation = {
    schemaPublish: {
        __typename: 'GitHubSchemaPublishError';
    } & {
        message?: string;
    } | {
        __typename: 'GitHubSchemaPublishSuccess';
    } & {
        message?: string;
    } | {
        __typename: 'SchemaPublishError';
    } & {
        valid?: boolean;
        linkToWebsite?: string | null;
        changes?: ({
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
        errors?: {
            ' $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?: ({
            edges: Array<{
                __typename: 'SchemaChangeEdge';
            }>;
        } & {
            ' $fragmentRefs'?: {
                'RenderChanges_SchemaChangesFragment': RenderChanges_SchemaChangesFragment;
            };
        }) | null;
    };
};
export type MyTokenInfoQueryVariables = Exact<{
    showAll: boolean;
}>;
export type MyTokenInfoQuery = {
    whoAmI: {
        title: string;
        resolvedPermissions: Array<{
            level: PermissionLevelType;
            resolvedResourceIds: Array<string> | null;
            title: string;
            resolvedPermissionGroups: Array<{
                title: string;
                permissions: Array<{
                    isGranted: boolean;
                    permission: {
                        id: string;
                        title: string;
                        description: string;
                    };
                }>;
            }>;
        }>;
    } | null;
};
export type RenderErrors_SchemaErrorConnectionFragmentFragment = {
    edges: Array<{
        node: {
            message: string;
        };
    }>;
} & {
    ' $fragmentName'?: 'RenderErrors_SchemaErrorConnectionFragmentFragment';
};
export type RenderChanges_SchemaChangesFragment = {
    edges: Array<{
        node: {
            severityLevel: SeverityLevelType;
            isSafeBasedOnUsage: boolean;
            message: string;
            approval: {
                approvedBy: {
                    displayName: string;
                } | null;
            } | null;
            affectedAppDeployments: {
                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 Cli_SchemaCheckMutationDocument: DocumentNode<Cli_SchemaCheckMutationMutation, Cli_SchemaCheckMutationMutationVariables>;
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>;
export {};
//# sourceMappingURL=graphql.d.ts.map