import * as Apollo from '@apollo/client';
export declare type Maybe<T> = T | undefined;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export interface Scalars {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    InstantTime: string;
    JSON: any;
}
export interface MdAction {
    __typename?: 'MdAction';
    id: Scalars['String'];
    actionId: Scalars['String'];
    type: Scalars['String'];
    status: MdActionStatus;
    startedAt?: Maybe<Scalars['InstantTime']>;
    completedAt?: Maybe<Scalars['InstantTime']>;
    link?: Maybe<Scalars['String']>;
    actionType: MdActionType;
}
export declare type MdActionStatus = 'NOT_EVALUATED' | 'PENDING' | 'PASS' | 'FAIL' | 'FORCE_PASS';
export declare type MdActionType = 'VERIFICATION' | 'POST_DEPLOY';
export interface MdApplication {
    __typename?: 'MdApplication';
    id: Scalars['String'];
    name: Scalars['String'];
    account: Scalars['String'];
    isPaused?: Maybe<Scalars['Boolean']>;
    pausedInfo?: Maybe<MdPausedInfo>;
    environments: Array<MdEnvironment>;
    notifications?: Maybe<Array<MdNotification>>;
    gitIntegration?: Maybe<MdGitIntegration>;
    config?: Maybe<MdConfig>;
}
export interface MdArtifact {
    __typename?: 'MdArtifact';
    id: Scalars['String'];
    environment: Scalars['String'];
    name: Scalars['String'];
    type: Scalars['String'];
    reference: Scalars['String'];
    versions?: Maybe<Array<MdArtifactVersionInEnvironment>>;
    pinnedVersion?: Maybe<MdPinnedVersion>;
    latestApprovedVersion?: Maybe<MdArtifactVersionInEnvironment>;
    resources?: Maybe<Array<MdResource>>;
}
export interface MdArtifactVersionsArgs {
    statuses?: Maybe<Array<MdArtifactStatusInEnvironment>>;
    versions?: Maybe<Array<Scalars['String']>>;
    limit?: Maybe<Scalars['Int']>;
}
export declare type MdArtifactStatusInEnvironment = 'PENDING' | 'APPROVED' | 'DEPLOYING' | 'CURRENT' | 'PREVIOUS' | 'VETOED' | 'SKIPPED';
export interface MdArtifactVersionActionPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    reference: Scalars['String'];
    comment: Scalars['String'];
    version: Scalars['String'];
}
export interface MdArtifactVersionInEnvironment {
    __typename?: 'MdArtifactVersionInEnvironment';
    id: Scalars['String'];
    version: Scalars['String'];
    buildNumber?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['InstantTime']>;
    deployedAt?: Maybe<Scalars['InstantTime']>;
    gitMetadata?: Maybe<MdGitMetadata>;
    packageDiff?: Maybe<MdPackageDiff>;
    environment?: Maybe<Scalars['String']>;
    reference: Scalars['String'];
    status?: Maybe<MdArtifactStatusInEnvironment>;
    lifecycleSteps?: Maybe<Array<MdLifecycleStep>>;
    constraints?: Maybe<Array<MdConstraint>>;
    verifications?: Maybe<Array<MdAction>>;
    postDeploy?: Maybe<Array<MdAction>>;
    veto?: Maybe<MdVersionVeto>;
    isCurrent?: Maybe<Scalars['Boolean']>;
}
export interface MdCommitInfo {
    __typename?: 'MdCommitInfo';
    sha?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
}
export interface MdComparisonLinks {
    __typename?: 'MdComparisonLinks';
    toPreviousVersion?: Maybe<Scalars['String']>;
    toCurrentVersion?: Maybe<Scalars['String']>;
}
export interface MdConfig {
    __typename?: 'MdConfig';
    id: Scalars['ID'];
    updatedAt?: Maybe<Scalars['InstantTime']>;
    rawConfig?: Maybe<Scalars['String']>;
    processedConfig?: Maybe<Scalars['String']>;
    previewEnvironmentsConfigured?: Maybe<Scalars['Boolean']>;
}
export interface MdConstraint {
    __typename?: 'MdConstraint';
    type: Scalars['String'];
    status: MdConstraintStatus;
    startedAt?: Maybe<Scalars['InstantTime']>;
    judgedAt?: Maybe<Scalars['InstantTime']>;
    judgedBy?: Maybe<Scalars['String']>;
    comment?: Maybe<Scalars['String']>;
    attributes?: Maybe<Scalars['JSON']>;
}
export declare type MdConstraintStatus = 'BLOCKED' | 'PENDING' | 'PASS' | 'FAIL' | 'FORCE_PASS';
export interface MdConstraintStatusPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    type: Scalars['String'];
    version: Scalars['String'];
    reference: Scalars['String'];
    status: MdConstraintStatus;
}
export interface MdDeployLocation {
    __typename?: 'MdDeployLocation';
    account?: Maybe<Scalars['String']>;
    region?: Maybe<Scalars['String']>;
    sublocations?: Maybe<Array<Scalars['String']>>;
}
export interface MdDeployTarget {
    __typename?: 'MdDeployTarget';
    cloudProvider?: Maybe<Scalars['String']>;
    location?: Maybe<MdDeployLocation>;
    status?: Maybe<MdRolloutTargetStatus>;
}
export interface MdDismissNotificationPayload {
    application: Scalars['String'];
    id: Scalars['String'];
}
export interface MdEnvironment {
    __typename?: 'MdEnvironment';
    id: Scalars['ID'];
    name: Scalars['String'];
    state: MdEnvironmentState;
    isPreview?: Maybe<Scalars['Boolean']>;
    isDeleting?: Maybe<Scalars['Boolean']>;
    gitMetadata?: Maybe<MdGitMetadata>;
    basedOn?: Maybe<Scalars['String']>;
}
export interface MdEnvironmentState {
    __typename?: 'MdEnvironmentState';
    id: Scalars['String'];
    resources?: Maybe<Array<MdResource>>;
    artifacts?: Maybe<Array<MdArtifact>>;
}
export declare type MdEventLevel = 'SUCCESS' | 'INFO' | 'WARNING' | 'ERROR';
export interface MdExecutionSummary {
    __typename?: 'MdExecutionSummary';
    status: MdTaskStatus;
    currentStage?: Maybe<MdStageDetail>;
    stages?: Maybe<Array<MdStageDetail>>;
    deployTargets?: Maybe<Array<MdDeployTarget>>;
    completedDeployTargets?: Maybe<Array<MdDeployTarget>>;
    error?: Maybe<Scalars['String']>;
}
export interface MdGitIntegration {
    __typename?: 'MdGitIntegration';
    id: Scalars['String'];
    repository?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    isEnabled?: Maybe<Scalars['Boolean']>;
    manifestPath?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
}
export interface MdGitMetadata {
    __typename?: 'MdGitMetadata';
    commit?: Maybe<Scalars['String']>;
    author?: Maybe<Scalars['String']>;
    project?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    repoName?: Maybe<Scalars['String']>;
    pullRequest?: Maybe<MdPullRequest>;
    commitInfo?: Maybe<MdCommitInfo>;
    comparisonLinks?: Maybe<MdComparisonLinks>;
}
export declare type MdLifecycleEventScope = 'PRE_DEPLOYMENT';
export declare type MdLifecycleEventStatus = 'NOT_STARTED' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'ABORTED' | 'UNKNOWN';
export declare type MdLifecycleEventType = 'BAKE' | 'BUILD';
export interface MdLifecycleStep {
    __typename?: 'MdLifecycleStep';
    scope?: Maybe<MdLifecycleEventScope>;
    type: MdLifecycleEventType;
    id?: Maybe<Scalars['String']>;
    status: MdLifecycleEventStatus;
    text?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    startedAt?: Maybe<Scalars['InstantTime']>;
    completedAt?: Maybe<Scalars['InstantTime']>;
    artifactVersion?: Maybe<Scalars['String']>;
}
export interface MdLocation {
    __typename?: 'MdLocation';
    account?: Maybe<Scalars['String']>;
    regions?: Maybe<Array<Scalars['String']>>;
}
export interface MdMarkArtifactVersionAsGoodPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    reference: Scalars['String'];
    version: Scalars['String'];
}
export interface MdMoniker {
    __typename?: 'MdMoniker';
    app?: Maybe<Scalars['String']>;
    stack?: Maybe<Scalars['String']>;
    detail?: Maybe<Scalars['String']>;
}
export interface MdNotification {
    __typename?: 'MdNotification';
    id: Scalars['String'];
    level: MdEventLevel;
    message: Scalars['String'];
    triggeredAt?: Maybe<Scalars['InstantTime']>;
    triggeredBy?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    isActive?: Maybe<Scalars['Boolean']>;
    dismissedAt?: Maybe<Scalars['InstantTime']>;
    dismissedBy?: Maybe<Scalars['String']>;
}
export interface MdPackageAndVersion {
    __typename?: 'MdPackageAndVersion';
    package: Scalars['String'];
    version: Scalars['String'];
}
export interface MdPackageAndVersionChange {
    __typename?: 'MdPackageAndVersionChange';
    package: Scalars['String'];
    oldVersion: Scalars['String'];
    newVersion: Scalars['String'];
}
export interface MdPackageDiff {
    __typename?: 'MdPackageDiff';
    added?: Maybe<Array<MdPackageAndVersion>>;
    removed?: Maybe<Array<MdPackageAndVersion>>;
    changed?: Maybe<Array<MdPackageAndVersionChange>>;
}
export interface MdPausedInfo {
    __typename?: 'MdPausedInfo';
    id: Scalars['String'];
    by?: Maybe<Scalars['String']>;
    at?: Maybe<Scalars['InstantTime']>;
    comment?: Maybe<Scalars['String']>;
}
export interface MdPinnedVersion {
    __typename?: 'MdPinnedVersion';
    id: Scalars['String'];
    name: Scalars['String'];
    reference: Scalars['String'];
    version: Scalars['String'];
    gitMetadata?: Maybe<MdGitMetadata>;
    buildNumber?: Maybe<Scalars['String']>;
    pinnedAt?: Maybe<Scalars['InstantTime']>;
    pinnedBy?: Maybe<Scalars['String']>;
    comment?: Maybe<Scalars['String']>;
}
export interface MdPullRequest {
    __typename?: 'MdPullRequest';
    number?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
}
export interface MdResource {
    __typename?: 'MdResource';
    id: Scalars['String'];
    kind: Scalars['String'];
    moniker?: Maybe<MdMoniker>;
    state?: Maybe<MdResourceActuationState>;
    artifact?: Maybe<MdArtifact>;
    displayName?: Maybe<Scalars['String']>;
    location?: Maybe<MdLocation>;
    rawDefinition?: Maybe<Scalars['String']>;
}
export interface MdResourceActuationState {
    __typename?: 'MdResourceActuationState';
    resourceId: Scalars['String'];
    status: MdResourceActuationStatus;
    reason?: Maybe<Scalars['String']>;
    event?: Maybe<Scalars['String']>;
    tasks?: Maybe<Array<MdResourceTask>>;
}
export declare type MdResourceActuationStatus = 'PROCESSING' | 'UP_TO_DATE' | 'ERROR' | 'WAITING' | 'NOT_MANAGED' | 'DELETING';
export interface MdResourceTask {
    __typename?: 'MdResourceTask';
    id: Scalars['String'];
    name: Scalars['String'];
    running: Scalars['Boolean'];
    summary?: Maybe<MdExecutionSummary>;
}
export interface MdRestartConstraintEvaluationPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    type: Scalars['String'];
    reference: Scalars['String'];
    version: Scalars['String'];
}
export interface MdRetryArtifactActionPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    reference: Scalars['String'];
    version: Scalars['String'];
    actionId: Scalars['String'];
    actionType: MdActionType;
}
export declare type MdRolloutTargetStatus = 'NOT_STARTED' | 'RUNNING' | 'SUCCEEDED' | 'FAILED';
export interface MdStageDetail {
    __typename?: 'MdStageDetail';
    id?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    startTime?: Maybe<Scalars['InstantTime']>;
    endTime?: Maybe<Scalars['InstantTime']>;
    status?: Maybe<MdTaskStatus>;
    refId?: Maybe<Scalars['String']>;
    requisiteStageRefIds?: Maybe<Array<Scalars['String']>>;
}
export declare type MdTaskStatus = 'NOT_STARTED' | 'RUNNING' | 'PAUSED' | 'SUSPENDED' | 'SUCCEEDED' | 'FAILED_CONTINUE' | 'TERMINAL' | 'CANCELED' | 'REDIRECT' | 'STOPPED' | 'BUFFERED' | 'SKIPPED';
export interface MdToggleResourceManagementPayload {
    id: Scalars['ID'];
    isPaused: Scalars['Boolean'];
}
export interface MdUnpinArtifactVersionPayload {
    application: Scalars['String'];
    environment: Scalars['String'];
    reference: Scalars['String'];
}
export interface MdUpdateGitIntegrationPayload {
    application: Scalars['String'];
    isEnabled?: Maybe<Scalars['Boolean']>;
    manifestPath?: Maybe<Scalars['String']>;
}
export interface MdVersionVeto {
    __typename?: 'MdVersionVeto';
    vetoedBy?: Maybe<Scalars['String']>;
    vetoedAt?: Maybe<Scalars['InstantTime']>;
    comment?: Maybe<Scalars['String']>;
}
export interface Mutation {
    __typename?: 'Mutation';
    updateConstraintStatus?: Maybe<Scalars['Boolean']>;
    restartConstraintEvaluation?: Maybe<Scalars['Boolean']>;
    toggleManagement?: Maybe<Scalars['Boolean']>;
    pinArtifactVersion?: Maybe<Scalars['Boolean']>;
    markArtifactVersionAsBad?: Maybe<Scalars['Boolean']>;
    unpinArtifactVersion?: Maybe<Scalars['Boolean']>;
    markArtifactVersionAsGood?: Maybe<Scalars['Boolean']>;
    retryArtifactVersionAction?: Maybe<MdAction>;
    dismissNotification?: Maybe<Scalars['Boolean']>;
    updateGitIntegration?: Maybe<MdGitIntegration>;
    toggleResourceManagement?: Maybe<Scalars['Boolean']>;
    importDeliveryConfig?: Maybe<Scalars['Boolean']>;
}
export interface MutationUpdateConstraintStatusArgs {
    payload: MdConstraintStatusPayload;
}
export interface MutationRestartConstraintEvaluationArgs {
    payload: MdRestartConstraintEvaluationPayload;
}
export interface MutationToggleManagementArgs {
    application: Scalars['ID'];
    isPaused: Scalars['Boolean'];
    comment?: Maybe<Scalars['String']>;
}
export interface MutationPinArtifactVersionArgs {
    payload: MdArtifactVersionActionPayload;
}
export interface MutationMarkArtifactVersionAsBadArgs {
    payload: MdArtifactVersionActionPayload;
}
export interface MutationUnpinArtifactVersionArgs {
    payload: MdUnpinArtifactVersionPayload;
}
export interface MutationMarkArtifactVersionAsGoodArgs {
    payload: MdMarkArtifactVersionAsGoodPayload;
}
export interface MutationRetryArtifactVersionActionArgs {
    payload?: Maybe<MdRetryArtifactActionPayload>;
}
export interface MutationDismissNotificationArgs {
    payload: MdDismissNotificationPayload;
}
export interface MutationUpdateGitIntegrationArgs {
    payload?: Maybe<MdUpdateGitIntegrationPayload>;
}
export interface MutationToggleResourceManagementArgs {
    payload?: Maybe<MdToggleResourceManagementPayload>;
}
export interface MutationImportDeliveryConfigArgs {
    application: Scalars['String'];
}
export interface Query {
    __typename?: 'Query';
    application?: Maybe<MdApplication>;
}
export interface QueryApplicationArgs {
    appName: Scalars['String'];
}
export declare type ActionDetailsFragment = {
    __typename?: 'MdAction';
} & Pick<MdAction, 'id' | 'actionId' | 'actionType' | 'status' | 'startedAt' | 'completedAt' | 'link'>;
export declare type DetailedVersionFieldsFragment = {
    __typename?: 'MdArtifactVersionInEnvironment';
} & Pick<MdArtifactVersionInEnvironment, 'id' | 'buildNumber' | 'version' | 'createdAt' | 'status' | 'isCurrent' | 'deployedAt'> & {
    gitMetadata?: Maybe<{
        __typename?: 'MdGitMetadata';
    } & Pick<MdGitMetadata, 'commit' | 'author' | 'branch'> & {
        commitInfo?: Maybe<{
            __typename?: 'MdCommitInfo';
        } & Pick<MdCommitInfo, 'sha' | 'link' | 'message'>>;
        pullRequest?: Maybe<{
            __typename?: 'MdPullRequest';
        } & Pick<MdPullRequest, 'number' | 'link'>>;
        comparisonLinks?: Maybe<{
            __typename?: 'MdComparisonLinks';
        } & Pick<MdComparisonLinks, 'toPreviousVersion' | 'toCurrentVersion'>>;
    }>;
    lifecycleSteps?: Maybe<Array<{
        __typename?: 'MdLifecycleStep';
    } & Pick<MdLifecycleStep, 'startedAt' | 'completedAt' | 'type' | 'status' | 'link'>>>;
    constraints?: Maybe<Array<{
        __typename?: 'MdConstraint';
    } & Pick<MdConstraint, 'type' | 'status' | 'judgedBy' | 'judgedAt' | 'attributes'>>>;
    verifications?: Maybe<Array<{
        __typename?: 'MdAction';
    } & ActionDetailsFragment>>;
    postDeploy?: Maybe<Array<{
        __typename?: 'MdAction';
    } & ActionDetailsFragment>>;
    veto?: Maybe<{
        __typename?: 'MdVersionVeto';
    } & Pick<MdVersionVeto, 'vetoedBy' | 'vetoedAt' | 'comment'>>;
};
export declare type ArtifactPinnedVersionFieldsFragment = {
    __typename?: 'MdArtifact';
} & {
    pinnedVersion?: Maybe<{
        __typename?: 'MdPinnedVersion';
    } & Pick<MdPinnedVersion, 'id' | 'version' | 'buildNumber' | 'pinnedAt' | 'pinnedBy' | 'comment'> & {
        gitMetadata?: Maybe<{
            __typename?: 'MdGitMetadata';
        } & {
            commitInfo?: Maybe<{
                __typename?: 'MdCommitInfo';
            } & Pick<MdCommitInfo, 'message'>>;
        }>;
    }>;
};
export declare type BaseEnvironmentFieldsFragment = {
    __typename?: 'MdEnvironment';
} & Pick<MdEnvironment, 'id' | 'name' | 'isPreview' | 'basedOn'> & {
    gitMetadata?: Maybe<{
        __typename?: 'MdGitMetadata';
    } & Pick<MdGitMetadata, 'branch'> & {
        pullRequest?: Maybe<{
            __typename?: 'MdPullRequest';
        } & Pick<MdPullRequest, 'link'>>;
    }>;
};
export declare type BaesResourceFieldsFragment = {
    __typename?: 'MdResource';
} & Pick<MdResource, 'id' | 'kind' | 'displayName' | 'rawDefinition'> & {
    moniker?: Maybe<{
        __typename?: 'MdMoniker';
    } & Pick<MdMoniker, 'app' | 'stack' | 'detail'>>;
    location?: Maybe<{
        __typename?: 'MdLocation';
    } & Pick<MdLocation, 'account' | 'regions'>>;
};
export declare type FetchApplicationQueryVariables = Exact<{
    appName: Scalars['String'];
    statuses?: Maybe<Array<MdArtifactStatusInEnvironment> | MdArtifactStatusInEnvironment>;
}>;
export declare type FetchApplicationQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name'> & {
        config?: Maybe<{
            __typename?: 'MdConfig';
        } & Pick<MdConfig, 'id' | 'previewEnvironmentsConfigured'>>;
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & Pick<MdEnvironment, 'isDeleting'> & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & Pick<MdEnvironmentState, 'id'> & {
                artifacts?: Maybe<Array<{
                    __typename?: 'MdArtifact';
                } & Pick<MdArtifact, 'id' | 'name' | 'environment' | 'type' | 'reference'> & {
                    versions?: Maybe<Array<{
                        __typename?: 'MdArtifactVersionInEnvironment';
                    } & DetailedVersionFieldsFragment>>;
                    resources?: Maybe<Array<{
                        __typename?: 'MdResource';
                    } & BaesResourceFieldsFragment>>;
                } & ArtifactPinnedVersionFieldsFragment>>;
                resources?: Maybe<Array<{
                    __typename?: 'MdResource';
                } & BaesResourceFieldsFragment>>;
            };
        } & BaseEnvironmentFieldsFragment>;
    }>;
};
export declare type FetchCurrentVersionQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchCurrentVersionQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name'> & {
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & Pick<MdEnvironment, 'id' | 'name'> & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & {
                artifacts?: Maybe<Array<{
                    __typename?: 'MdArtifact';
                } & Pick<MdArtifact, 'id' | 'name' | 'reference' | 'environment'> & {
                    versions?: Maybe<Array<{
                        __typename?: 'MdArtifactVersionInEnvironment';
                    } & Pick<MdArtifactVersionInEnvironment, 'id' | 'version' | 'buildNumber' | 'createdAt'> & {
                        gitMetadata?: Maybe<{
                            __typename?: 'MdGitMetadata';
                        } & Pick<MdGitMetadata, 'commit'> & {
                            commitInfo?: Maybe<{
                                __typename?: 'MdCommitInfo';
                            } & Pick<MdCommitInfo, 'sha' | 'message'>>;
                        }>;
                    }>>;
                }>>;
            };
        }>;
    }>;
};
export declare type FetchVersionsHistoryQueryVariables = Exact<{
    appName: Scalars['String'];
    limit?: Maybe<Scalars['Int']>;
}>;
export declare type FetchVersionsHistoryQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name'> & {
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & Pick<MdEnvironmentState, 'id'> & {
                artifacts?: Maybe<Array<{
                    __typename?: 'MdArtifact';
                } & Pick<MdArtifact, 'id' | 'name' | 'environment' | 'type' | 'reference'> & {
                    versions?: Maybe<Array<{
                        __typename?: 'MdArtifactVersionInEnvironment';
                    } & Pick<MdArtifactVersionInEnvironment, 'id' | 'buildNumber' | 'version' | 'createdAt' | 'status' | 'isCurrent'> & {
                        gitMetadata?: Maybe<{
                            __typename?: 'MdGitMetadata';
                        } & Pick<MdGitMetadata, 'commit' | 'author' | 'branch'> & {
                            commitInfo?: Maybe<{
                                __typename?: 'MdCommitInfo';
                            } & Pick<MdCommitInfo, 'sha' | 'link' | 'message'>>;
                            pullRequest?: Maybe<{
                                __typename?: 'MdPullRequest';
                            } & Pick<MdPullRequest, 'number' | 'link'>>;
                        }>;
                    }>>;
                } & ArtifactPinnedVersionFieldsFragment>>;
            };
        } & BaseEnvironmentFieldsFragment>;
    }>;
};
export declare type FetchPinnedVersionsQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchPinnedVersionsQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name' | 'account'> & {
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & Pick<MdEnvironment, 'id' | 'name'> & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & Pick<MdEnvironmentState, 'id'> & {
                artifacts?: Maybe<Array<{
                    __typename?: 'MdArtifact';
                } & Pick<MdArtifact, 'id' | 'name' | 'environment' | 'type' | 'reference'> & ArtifactPinnedVersionFieldsFragment>>;
            };
        }>;
    }>;
};
export declare type FetchVersionQueryVariables = Exact<{
    appName: Scalars['String'];
    versions?: Maybe<Array<Scalars['String']> | Scalars['String']>;
}>;
export declare type FetchVersionQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name' | 'account'> & {
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & Pick<MdEnvironment, 'id' | 'name'> & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & Pick<MdEnvironmentState, 'id'> & {
                artifacts?: Maybe<Array<{
                    __typename?: 'MdArtifact';
                } & Pick<MdArtifact, 'id' | 'name' | 'environment' | 'type' | 'reference'> & {
                    versions?: Maybe<Array<{
                        __typename?: 'MdArtifactVersionInEnvironment';
                    } & DetailedVersionFieldsFragment>>;
                }>>;
            };
        }>;
    }>;
};
export declare type FetchResourceStatusQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchResourceStatusQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name'> & {
        environments: Array<{
            __typename?: 'MdEnvironment';
        } & Pick<MdEnvironment, 'id' | 'name'> & {
            state: {
                __typename?: 'MdEnvironmentState';
            } & Pick<MdEnvironmentState, 'id'> & {
                resources?: Maybe<Array<{
                    __typename?: 'MdResource';
                } & Pick<MdResource, 'id' | 'kind'> & {
                    state?: Maybe<{
                        __typename?: 'MdResourceActuationState';
                    } & Pick<MdResourceActuationState, 'status' | 'reason' | 'event'> & {
                        tasks?: Maybe<Array<{
                            __typename?: 'MdResourceTask';
                        } & Pick<MdResourceTask, 'id' | 'name'>>>;
                    }>;
                }>>;
            };
        }>;
    }>;
};
export declare type FetchNotificationsQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchNotificationsQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name'> & {
        notifications?: Maybe<Array<{
            __typename?: 'MdNotification';
        } & Pick<MdNotification, 'id' | 'level' | 'message' | 'triggeredAt' | 'link'>>>;
    }>;
};
export declare type FetchApplicationManagementDataQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchApplicationManagementDataQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name' | 'isPaused'> & {
        config?: Maybe<{
            __typename?: 'MdConfig';
        } & Pick<MdConfig, 'id' | 'updatedAt' | 'rawConfig' | 'processedConfig'>>;
        gitIntegration?: Maybe<{
            __typename?: 'MdGitIntegration';
        } & Pick<MdGitIntegration, 'id' | 'repository' | 'branch' | 'isEnabled' | 'link' | 'manifestPath'>>;
    }>;
};
export declare type FetchApplicationManagementStatusQueryVariables = Exact<{
    appName: Scalars['String'];
}>;
export declare type FetchApplicationManagementStatusQuery = {
    __typename?: 'Query';
} & {
    application?: Maybe<{
        __typename?: 'MdApplication';
    } & Pick<MdApplication, 'id' | 'name' | 'isPaused'>>;
};
export declare type UpdateConstraintMutationVariables = Exact<{
    payload: MdConstraintStatusPayload;
}>;
export declare type UpdateConstraintMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'updateConstraintStatus'>;
export declare type ToggleManagementMutationVariables = Exact<{
    application: Scalars['ID'];
    isPaused: Scalars['Boolean'];
}>;
export declare type ToggleManagementMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'toggleManagement'>;
export declare type PinVersionMutationVariables = Exact<{
    payload: MdArtifactVersionActionPayload;
}>;
export declare type PinVersionMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'pinArtifactVersion'>;
export declare type UnpinVersionMutationVariables = Exact<{
    payload: MdUnpinArtifactVersionPayload;
}>;
export declare type UnpinVersionMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'unpinArtifactVersion'>;
export declare type MarkVersionAsBadMutationVariables = Exact<{
    payload: MdArtifactVersionActionPayload;
}>;
export declare type MarkVersionAsBadMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'markArtifactVersionAsBad'>;
export declare type MarkVersionAsGoodMutationVariables = Exact<{
    payload: MdMarkArtifactVersionAsGoodPayload;
}>;
export declare type MarkVersionAsGoodMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'markArtifactVersionAsGood'>;
export declare type RetryVersionActionMutationVariables = Exact<{
    payload: MdRetryArtifactActionPayload;
}>;
export declare type RetryVersionActionMutation = {
    __typename?: 'Mutation';
} & {
    retryArtifactVersionAction?: Maybe<{
        __typename?: 'MdAction';
    } & ActionDetailsFragment>;
};
export declare type UpdateGitIntegrationMutationVariables = Exact<{
    payload: MdUpdateGitIntegrationPayload;
}>;
export declare type UpdateGitIntegrationMutation = {
    __typename?: 'Mutation';
} & {
    updateGitIntegration?: Maybe<{
        __typename?: 'MdGitIntegration';
    } & Pick<MdGitIntegration, 'id' | 'isEnabled'>>;
};
export declare type DismissNotificationMutationVariables = Exact<{
    payload: MdDismissNotificationPayload;
}>;
export declare type DismissNotificationMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'dismissNotification'>;
export declare type ImportDeliveryConfigMutationVariables = Exact<{
    application: Scalars['String'];
}>;
export declare type ImportDeliveryConfigMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'importDeliveryConfig'>;
export declare type ToggleResourceManagementMutationVariables = Exact<{
    payload?: Maybe<MdToggleResourceManagementPayload>;
}>;
export declare type ToggleResourceManagementMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'toggleResourceManagement'>;
export declare type RestartConstraintEvaluationMutationVariables = Exact<{
    payload: MdRestartConstraintEvaluationPayload;
}>;
export declare type RestartConstraintEvaluationMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'restartConstraintEvaluation'>;
export declare const ActionDetailsFragmentDoc: Apollo.DocumentNode;
export declare const DetailedVersionFieldsFragmentDoc: Apollo.DocumentNode;
export declare const ArtifactPinnedVersionFieldsFragmentDoc: Apollo.DocumentNode;
export declare const BaseEnvironmentFieldsFragmentDoc: Apollo.DocumentNode;
export declare const BaesResourceFieldsFragmentDoc: Apollo.DocumentNode;
export declare const FetchApplicationDocument: Apollo.DocumentNode;
/**
 * __useFetchApplicationQuery__
 *
 * To run a query within a React component, call `useFetchApplicationQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchApplicationQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchApplicationQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *      statuses: // value for 'statuses'
 *   },
 * });
 */
export declare function useFetchApplicationQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>): Apollo.QueryResult<FetchApplicationQuery, Exact<{
    appName: string;
    statuses?: MdArtifactStatusInEnvironment | MdArtifactStatusInEnvironment[];
}>>;
export declare function useFetchApplicationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>): Apollo.LazyQueryResultTuple<FetchApplicationQuery, Exact<{
    appName: string;
    statuses?: MdArtifactStatusInEnvironment | MdArtifactStatusInEnvironment[];
}>>;
export declare type FetchApplicationQueryHookResult = ReturnType<typeof useFetchApplicationQuery>;
export declare type FetchApplicationLazyQueryHookResult = ReturnType<typeof useFetchApplicationLazyQuery>;
export declare type FetchApplicationQueryResult = Apollo.QueryResult<FetchApplicationQuery, FetchApplicationQueryVariables>;
export declare const FetchCurrentVersionDocument: Apollo.DocumentNode;
/**
 * __useFetchCurrentVersionQuery__
 *
 * To run a query within a React component, call `useFetchCurrentVersionQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchCurrentVersionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchCurrentVersionQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchCurrentVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>): Apollo.QueryResult<FetchCurrentVersionQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchCurrentVersionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>): Apollo.LazyQueryResultTuple<FetchCurrentVersionQuery, Exact<{
    appName: string;
}>>;
export declare type FetchCurrentVersionQueryHookResult = ReturnType<typeof useFetchCurrentVersionQuery>;
export declare type FetchCurrentVersionLazyQueryHookResult = ReturnType<typeof useFetchCurrentVersionLazyQuery>;
export declare type FetchCurrentVersionQueryResult = Apollo.QueryResult<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>;
export declare const FetchVersionsHistoryDocument: Apollo.DocumentNode;
/**
 * __useFetchVersionsHistoryQuery__
 *
 * To run a query within a React component, call `useFetchVersionsHistoryQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchVersionsHistoryQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchVersionsHistoryQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export declare function useFetchVersionsHistoryQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>): Apollo.QueryResult<FetchVersionsHistoryQuery, Exact<{
    appName: string;
    limit?: number;
}>>;
export declare function useFetchVersionsHistoryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>): Apollo.LazyQueryResultTuple<FetchVersionsHistoryQuery, Exact<{
    appName: string;
    limit?: number;
}>>;
export declare type FetchVersionsHistoryQueryHookResult = ReturnType<typeof useFetchVersionsHistoryQuery>;
export declare type FetchVersionsHistoryLazyQueryHookResult = ReturnType<typeof useFetchVersionsHistoryLazyQuery>;
export declare type FetchVersionsHistoryQueryResult = Apollo.QueryResult<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>;
export declare const FetchPinnedVersionsDocument: Apollo.DocumentNode;
/**
 * __useFetchPinnedVersionsQuery__
 *
 * To run a query within a React component, call `useFetchPinnedVersionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchPinnedVersionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchPinnedVersionsQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchPinnedVersionsQuery(baseOptions: Apollo.QueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>): Apollo.QueryResult<FetchPinnedVersionsQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchPinnedVersionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>): Apollo.LazyQueryResultTuple<FetchPinnedVersionsQuery, Exact<{
    appName: string;
}>>;
export declare type FetchPinnedVersionsQueryHookResult = ReturnType<typeof useFetchPinnedVersionsQuery>;
export declare type FetchPinnedVersionsLazyQueryHookResult = ReturnType<typeof useFetchPinnedVersionsLazyQuery>;
export declare type FetchPinnedVersionsQueryResult = Apollo.QueryResult<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>;
export declare const FetchVersionDocument: Apollo.DocumentNode;
/**
 * __useFetchVersionQuery__
 *
 * To run a query within a React component, call `useFetchVersionQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchVersionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchVersionQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *      versions: // value for 'versions'
 *   },
 * });
 */
export declare function useFetchVersionQuery(baseOptions: Apollo.QueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>): Apollo.QueryResult<FetchVersionQuery, Exact<{
    appName: string;
    versions?: string | string[];
}>>;
export declare function useFetchVersionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>): Apollo.LazyQueryResultTuple<FetchVersionQuery, Exact<{
    appName: string;
    versions?: string | string[];
}>>;
export declare type FetchVersionQueryHookResult = ReturnType<typeof useFetchVersionQuery>;
export declare type FetchVersionLazyQueryHookResult = ReturnType<typeof useFetchVersionLazyQuery>;
export declare type FetchVersionQueryResult = Apollo.QueryResult<FetchVersionQuery, FetchVersionQueryVariables>;
export declare const FetchResourceStatusDocument: Apollo.DocumentNode;
/**
 * __useFetchResourceStatusQuery__
 *
 * To run a query within a React component, call `useFetchResourceStatusQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchResourceStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchResourceStatusQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchResourceStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>): Apollo.QueryResult<FetchResourceStatusQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchResourceStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>): Apollo.LazyQueryResultTuple<FetchResourceStatusQuery, Exact<{
    appName: string;
}>>;
export declare type FetchResourceStatusQueryHookResult = ReturnType<typeof useFetchResourceStatusQuery>;
export declare type FetchResourceStatusLazyQueryHookResult = ReturnType<typeof useFetchResourceStatusLazyQuery>;
export declare type FetchResourceStatusQueryResult = Apollo.QueryResult<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>;
export declare const FetchNotificationsDocument: Apollo.DocumentNode;
/**
 * __useFetchNotificationsQuery__
 *
 * To run a query within a React component, call `useFetchNotificationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchNotificationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchNotificationsQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchNotificationsQuery(baseOptions: Apollo.QueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>): Apollo.QueryResult<FetchNotificationsQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>): Apollo.LazyQueryResultTuple<FetchNotificationsQuery, Exact<{
    appName: string;
}>>;
export declare type FetchNotificationsQueryHookResult = ReturnType<typeof useFetchNotificationsQuery>;
export declare type FetchNotificationsLazyQueryHookResult = ReturnType<typeof useFetchNotificationsLazyQuery>;
export declare type FetchNotificationsQueryResult = Apollo.QueryResult<FetchNotificationsQuery, FetchNotificationsQueryVariables>;
export declare const FetchApplicationManagementDataDocument: Apollo.DocumentNode;
/**
 * __useFetchApplicationManagementDataQuery__
 *
 * To run a query within a React component, call `useFetchApplicationManagementDataQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchApplicationManagementDataQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchApplicationManagementDataQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchApplicationManagementDataQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>): Apollo.QueryResult<FetchApplicationManagementDataQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchApplicationManagementDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>): Apollo.LazyQueryResultTuple<FetchApplicationManagementDataQuery, Exact<{
    appName: string;
}>>;
export declare type FetchApplicationManagementDataQueryHookResult = ReturnType<typeof useFetchApplicationManagementDataQuery>;
export declare type FetchApplicationManagementDataLazyQueryHookResult = ReturnType<typeof useFetchApplicationManagementDataLazyQuery>;
export declare type FetchApplicationManagementDataQueryResult = Apollo.QueryResult<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>;
export declare const FetchApplicationManagementStatusDocument: Apollo.DocumentNode;
/**
 * __useFetchApplicationManagementStatusQuery__
 *
 * To run a query within a React component, call `useFetchApplicationManagementStatusQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchApplicationManagementStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchApplicationManagementStatusQuery({
 *   variables: {
 *      appName: // value for 'appName'
 *   },
 * });
 */
export declare function useFetchApplicationManagementStatusQuery(baseOptions: Apollo.QueryHookOptions<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>): Apollo.QueryResult<FetchApplicationManagementStatusQuery, Exact<{
    appName: string;
}>>;
export declare function useFetchApplicationManagementStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>): Apollo.LazyQueryResultTuple<FetchApplicationManagementStatusQuery, Exact<{
    appName: string;
}>>;
export declare type FetchApplicationManagementStatusQueryHookResult = ReturnType<typeof useFetchApplicationManagementStatusQuery>;
export declare type FetchApplicationManagementStatusLazyQueryHookResult = ReturnType<typeof useFetchApplicationManagementStatusLazyQuery>;
export declare type FetchApplicationManagementStatusQueryResult = Apollo.QueryResult<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>;
export declare const UpdateConstraintDocument: Apollo.DocumentNode;
export declare type UpdateConstraintMutationFn = Apollo.MutationFunction<UpdateConstraintMutation, UpdateConstraintMutationVariables>;
/**
 * __useUpdateConstraintMutation__
 *
 * To run a mutation, you first call `useUpdateConstraintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateConstraintMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateConstraintMutation, { data, loading, error }] = useUpdateConstraintMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useUpdateConstraintMutation(baseOptions?: Apollo.MutationHookOptions<UpdateConstraintMutation, UpdateConstraintMutationVariables>): Apollo.MutationTuple<UpdateConstraintMutation, Exact<{
    payload: MdConstraintStatusPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type UpdateConstraintMutationHookResult = ReturnType<typeof useUpdateConstraintMutation>;
export declare type UpdateConstraintMutationResult = Apollo.MutationResult<UpdateConstraintMutation>;
export declare type UpdateConstraintMutationOptions = Apollo.BaseMutationOptions<UpdateConstraintMutation, UpdateConstraintMutationVariables>;
export declare const ToggleManagementDocument: Apollo.DocumentNode;
export declare type ToggleManagementMutationFn = Apollo.MutationFunction<ToggleManagementMutation, ToggleManagementMutationVariables>;
/**
 * __useToggleManagementMutation__
 *
 * To run a mutation, you first call `useToggleManagementMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useToggleManagementMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [toggleManagementMutation, { data, loading, error }] = useToggleManagementMutation({
 *   variables: {
 *      application: // value for 'application'
 *      isPaused: // value for 'isPaused'
 *   },
 * });
 */
export declare function useToggleManagementMutation(baseOptions?: Apollo.MutationHookOptions<ToggleManagementMutation, ToggleManagementMutationVariables>): Apollo.MutationTuple<ToggleManagementMutation, Exact<{
    application: string;
    isPaused: boolean;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type ToggleManagementMutationHookResult = ReturnType<typeof useToggleManagementMutation>;
export declare type ToggleManagementMutationResult = Apollo.MutationResult<ToggleManagementMutation>;
export declare type ToggleManagementMutationOptions = Apollo.BaseMutationOptions<ToggleManagementMutation, ToggleManagementMutationVariables>;
export declare const PinVersionDocument: Apollo.DocumentNode;
export declare type PinVersionMutationFn = Apollo.MutationFunction<PinVersionMutation, PinVersionMutationVariables>;
/**
 * __usePinVersionMutation__
 *
 * To run a mutation, you first call `usePinVersionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `usePinVersionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [pinVersionMutation, { data, loading, error }] = usePinVersionMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function usePinVersionMutation(baseOptions?: Apollo.MutationHookOptions<PinVersionMutation, PinVersionMutationVariables>): Apollo.MutationTuple<PinVersionMutation, Exact<{
    payload: MdArtifactVersionActionPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type PinVersionMutationHookResult = ReturnType<typeof usePinVersionMutation>;
export declare type PinVersionMutationResult = Apollo.MutationResult<PinVersionMutation>;
export declare type PinVersionMutationOptions = Apollo.BaseMutationOptions<PinVersionMutation, PinVersionMutationVariables>;
export declare const UnpinVersionDocument: Apollo.DocumentNode;
export declare type UnpinVersionMutationFn = Apollo.MutationFunction<UnpinVersionMutation, UnpinVersionMutationVariables>;
/**
 * __useUnpinVersionMutation__
 *
 * To run a mutation, you first call `useUnpinVersionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUnpinVersionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [unpinVersionMutation, { data, loading, error }] = useUnpinVersionMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useUnpinVersionMutation(baseOptions?: Apollo.MutationHookOptions<UnpinVersionMutation, UnpinVersionMutationVariables>): Apollo.MutationTuple<UnpinVersionMutation, Exact<{
    payload: MdUnpinArtifactVersionPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type UnpinVersionMutationHookResult = ReturnType<typeof useUnpinVersionMutation>;
export declare type UnpinVersionMutationResult = Apollo.MutationResult<UnpinVersionMutation>;
export declare type UnpinVersionMutationOptions = Apollo.BaseMutationOptions<UnpinVersionMutation, UnpinVersionMutationVariables>;
export declare const MarkVersionAsBadDocument: Apollo.DocumentNode;
export declare type MarkVersionAsBadMutationFn = Apollo.MutationFunction<MarkVersionAsBadMutation, MarkVersionAsBadMutationVariables>;
/**
 * __useMarkVersionAsBadMutation__
 *
 * To run a mutation, you first call `useMarkVersionAsBadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMarkVersionAsBadMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [markVersionAsBadMutation, { data, loading, error }] = useMarkVersionAsBadMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useMarkVersionAsBadMutation(baseOptions?: Apollo.MutationHookOptions<MarkVersionAsBadMutation, MarkVersionAsBadMutationVariables>): Apollo.MutationTuple<MarkVersionAsBadMutation, Exact<{
    payload: MdArtifactVersionActionPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type MarkVersionAsBadMutationHookResult = ReturnType<typeof useMarkVersionAsBadMutation>;
export declare type MarkVersionAsBadMutationResult = Apollo.MutationResult<MarkVersionAsBadMutation>;
export declare type MarkVersionAsBadMutationOptions = Apollo.BaseMutationOptions<MarkVersionAsBadMutation, MarkVersionAsBadMutationVariables>;
export declare const MarkVersionAsGoodDocument: Apollo.DocumentNode;
export declare type MarkVersionAsGoodMutationFn = Apollo.MutationFunction<MarkVersionAsGoodMutation, MarkVersionAsGoodMutationVariables>;
/**
 * __useMarkVersionAsGoodMutation__
 *
 * To run a mutation, you first call `useMarkVersionAsGoodMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMarkVersionAsGoodMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [markVersionAsGoodMutation, { data, loading, error }] = useMarkVersionAsGoodMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useMarkVersionAsGoodMutation(baseOptions?: Apollo.MutationHookOptions<MarkVersionAsGoodMutation, MarkVersionAsGoodMutationVariables>): Apollo.MutationTuple<MarkVersionAsGoodMutation, Exact<{
    payload: MdMarkArtifactVersionAsGoodPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type MarkVersionAsGoodMutationHookResult = ReturnType<typeof useMarkVersionAsGoodMutation>;
export declare type MarkVersionAsGoodMutationResult = Apollo.MutationResult<MarkVersionAsGoodMutation>;
export declare type MarkVersionAsGoodMutationOptions = Apollo.BaseMutationOptions<MarkVersionAsGoodMutation, MarkVersionAsGoodMutationVariables>;
export declare const RetryVersionActionDocument: Apollo.DocumentNode;
export declare type RetryVersionActionMutationFn = Apollo.MutationFunction<RetryVersionActionMutation, RetryVersionActionMutationVariables>;
/**
 * __useRetryVersionActionMutation__
 *
 * To run a mutation, you first call `useRetryVersionActionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRetryVersionActionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [retryVersionActionMutation, { data, loading, error }] = useRetryVersionActionMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useRetryVersionActionMutation(baseOptions?: Apollo.MutationHookOptions<RetryVersionActionMutation, RetryVersionActionMutationVariables>): Apollo.MutationTuple<RetryVersionActionMutation, Exact<{
    payload: MdRetryArtifactActionPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type RetryVersionActionMutationHookResult = ReturnType<typeof useRetryVersionActionMutation>;
export declare type RetryVersionActionMutationResult = Apollo.MutationResult<RetryVersionActionMutation>;
export declare type RetryVersionActionMutationOptions = Apollo.BaseMutationOptions<RetryVersionActionMutation, RetryVersionActionMutationVariables>;
export declare const UpdateGitIntegrationDocument: Apollo.DocumentNode;
export declare type UpdateGitIntegrationMutationFn = Apollo.MutationFunction<UpdateGitIntegrationMutation, UpdateGitIntegrationMutationVariables>;
/**
 * __useUpdateGitIntegrationMutation__
 *
 * To run a mutation, you first call `useUpdateGitIntegrationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateGitIntegrationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateGitIntegrationMutation, { data, loading, error }] = useUpdateGitIntegrationMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useUpdateGitIntegrationMutation(baseOptions?: Apollo.MutationHookOptions<UpdateGitIntegrationMutation, UpdateGitIntegrationMutationVariables>): Apollo.MutationTuple<UpdateGitIntegrationMutation, Exact<{
    payload: MdUpdateGitIntegrationPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type UpdateGitIntegrationMutationHookResult = ReturnType<typeof useUpdateGitIntegrationMutation>;
export declare type UpdateGitIntegrationMutationResult = Apollo.MutationResult<UpdateGitIntegrationMutation>;
export declare type UpdateGitIntegrationMutationOptions = Apollo.BaseMutationOptions<UpdateGitIntegrationMutation, UpdateGitIntegrationMutationVariables>;
export declare const DismissNotificationDocument: Apollo.DocumentNode;
export declare type DismissNotificationMutationFn = Apollo.MutationFunction<DismissNotificationMutation, DismissNotificationMutationVariables>;
/**
 * __useDismissNotificationMutation__
 *
 * To run a mutation, you first call `useDismissNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDismissNotificationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [dismissNotificationMutation, { data, loading, error }] = useDismissNotificationMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useDismissNotificationMutation(baseOptions?: Apollo.MutationHookOptions<DismissNotificationMutation, DismissNotificationMutationVariables>): Apollo.MutationTuple<DismissNotificationMutation, Exact<{
    payload: MdDismissNotificationPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type DismissNotificationMutationHookResult = ReturnType<typeof useDismissNotificationMutation>;
export declare type DismissNotificationMutationResult = Apollo.MutationResult<DismissNotificationMutation>;
export declare type DismissNotificationMutationOptions = Apollo.BaseMutationOptions<DismissNotificationMutation, DismissNotificationMutationVariables>;
export declare const ImportDeliveryConfigDocument: Apollo.DocumentNode;
export declare type ImportDeliveryConfigMutationFn = Apollo.MutationFunction<ImportDeliveryConfigMutation, ImportDeliveryConfigMutationVariables>;
/**
 * __useImportDeliveryConfigMutation__
 *
 * To run a mutation, you first call `useImportDeliveryConfigMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useImportDeliveryConfigMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [importDeliveryConfigMutation, { data, loading, error }] = useImportDeliveryConfigMutation({
 *   variables: {
 *      application: // value for 'application'
 *   },
 * });
 */
export declare function useImportDeliveryConfigMutation(baseOptions?: Apollo.MutationHookOptions<ImportDeliveryConfigMutation, ImportDeliveryConfigMutationVariables>): Apollo.MutationTuple<ImportDeliveryConfigMutation, Exact<{
    application: string;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type ImportDeliveryConfigMutationHookResult = ReturnType<typeof useImportDeliveryConfigMutation>;
export declare type ImportDeliveryConfigMutationResult = Apollo.MutationResult<ImportDeliveryConfigMutation>;
export declare type ImportDeliveryConfigMutationOptions = Apollo.BaseMutationOptions<ImportDeliveryConfigMutation, ImportDeliveryConfigMutationVariables>;
export declare const ToggleResourceManagementDocument: Apollo.DocumentNode;
export declare type ToggleResourceManagementMutationFn = Apollo.MutationFunction<ToggleResourceManagementMutation, ToggleResourceManagementMutationVariables>;
/**
 * __useToggleResourceManagementMutation__
 *
 * To run a mutation, you first call `useToggleResourceManagementMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useToggleResourceManagementMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [toggleResourceManagementMutation, { data, loading, error }] = useToggleResourceManagementMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useToggleResourceManagementMutation(baseOptions?: Apollo.MutationHookOptions<ToggleResourceManagementMutation, ToggleResourceManagementMutationVariables>): Apollo.MutationTuple<ToggleResourceManagementMutation, Exact<{
    payload?: MdToggleResourceManagementPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type ToggleResourceManagementMutationHookResult = ReturnType<typeof useToggleResourceManagementMutation>;
export declare type ToggleResourceManagementMutationResult = Apollo.MutationResult<ToggleResourceManagementMutation>;
export declare type ToggleResourceManagementMutationOptions = Apollo.BaseMutationOptions<ToggleResourceManagementMutation, ToggleResourceManagementMutationVariables>;
export declare const RestartConstraintEvaluationDocument: Apollo.DocumentNode;
export declare type RestartConstraintEvaluationMutationFn = Apollo.MutationFunction<RestartConstraintEvaluationMutation, RestartConstraintEvaluationMutationVariables>;
/**
 * __useRestartConstraintEvaluationMutation__
 *
 * To run a mutation, you first call `useRestartConstraintEvaluationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRestartConstraintEvaluationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [restartConstraintEvaluationMutation, { data, loading, error }] = useRestartConstraintEvaluationMutation({
 *   variables: {
 *      payload: // value for 'payload'
 *   },
 * });
 */
export declare function useRestartConstraintEvaluationMutation(baseOptions?: Apollo.MutationHookOptions<RestartConstraintEvaluationMutation, RestartConstraintEvaluationMutationVariables>): Apollo.MutationTuple<RestartConstraintEvaluationMutation, Exact<{
    payload: MdRestartConstraintEvaluationPayload;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export declare type RestartConstraintEvaluationMutationHookResult = ReturnType<typeof useRestartConstraintEvaluationMutation>;
export declare type RestartConstraintEvaluationMutationResult = Apollo.MutationResult<RestartConstraintEvaluationMutation>;
export declare type RestartConstraintEvaluationMutationOptions = Apollo.BaseMutationOptions<RestartConstraintEvaluationMutation, RestartConstraintEvaluationMutationVariables>;
