/* eslint-disable @typescript-eslint/array-type */
import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
export type Maybe<T> = T | 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]> };
const defaultOptions = {};
/** 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 type MdActionStatus = 'NOT_EVALUATED' | 'PENDING' | 'PASS' | 'FAIL' | 'FORCE_PASS';

export 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 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 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 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 type MdLifecycleEventScope = 'PRE_DEPLOYMENT';

export type MdLifecycleEventStatus = 'NOT_STARTED' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'ABORTED' | 'UNKNOWN';

export 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 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 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 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 type ActionDetailsFragment = { __typename?: 'MdAction' } & Pick<
  MdAction,
  'id' | 'actionId' | 'actionType' | 'status' | 'startedAt' | 'completedAt' | 'link'
>;

export 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 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 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 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 type FetchApplicationQueryVariables = Exact<{
  appName: Scalars['String'];
  statuses?: Maybe<Array<MdArtifactStatusInEnvironment> | MdArtifactStatusInEnvironment>;
}>;

export 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 type FetchCurrentVersionQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export 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 type FetchVersionsHistoryQueryVariables = Exact<{
  appName: Scalars['String'];
  limit?: Maybe<Scalars['Int']>;
}>;

export 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 type FetchPinnedVersionsQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export 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 type FetchVersionQueryVariables = Exact<{
  appName: Scalars['String'];
  versions?: Maybe<Array<Scalars['String']> | Scalars['String']>;
}>;

export 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 type FetchResourceStatusQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export 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 type FetchNotificationsQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export 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 type FetchApplicationManagementDataQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export 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 type FetchApplicationManagementStatusQueryVariables = Exact<{
  appName: Scalars['String'];
}>;

export type FetchApplicationManagementStatusQuery = { __typename?: 'Query' } & {
  application?: Maybe<{ __typename?: 'MdApplication' } & Pick<MdApplication, 'id' | 'name' | 'isPaused'>>;
};

export type UpdateConstraintMutationVariables = Exact<{
  payload: MdConstraintStatusPayload;
}>;

export type UpdateConstraintMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'updateConstraintStatus'>;

export type ToggleManagementMutationVariables = Exact<{
  application: Scalars['ID'];
  isPaused: Scalars['Boolean'];
}>;

export type ToggleManagementMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'toggleManagement'>;

export type PinVersionMutationVariables = Exact<{
  payload: MdArtifactVersionActionPayload;
}>;

export type PinVersionMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'pinArtifactVersion'>;

export type UnpinVersionMutationVariables = Exact<{
  payload: MdUnpinArtifactVersionPayload;
}>;

export type UnpinVersionMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'unpinArtifactVersion'>;

export type MarkVersionAsBadMutationVariables = Exact<{
  payload: MdArtifactVersionActionPayload;
}>;

export type MarkVersionAsBadMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'markArtifactVersionAsBad'>;

export type MarkVersionAsGoodMutationVariables = Exact<{
  payload: MdMarkArtifactVersionAsGoodPayload;
}>;

export type MarkVersionAsGoodMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'markArtifactVersionAsGood'>;

export type RetryVersionActionMutationVariables = Exact<{
  payload: MdRetryArtifactActionPayload;
}>;

export type RetryVersionActionMutation = { __typename?: 'Mutation' } & {
  retryArtifactVersionAction?: Maybe<{ __typename?: 'MdAction' } & ActionDetailsFragment>;
};

export type UpdateGitIntegrationMutationVariables = Exact<{
  payload: MdUpdateGitIntegrationPayload;
}>;

export type UpdateGitIntegrationMutation = { __typename?: 'Mutation' } & {
  updateGitIntegration?: Maybe<{ __typename?: 'MdGitIntegration' } & Pick<MdGitIntegration, 'id' | 'isEnabled'>>;
};

export type DismissNotificationMutationVariables = Exact<{
  payload: MdDismissNotificationPayload;
}>;

export type DismissNotificationMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'dismissNotification'>;

export type ImportDeliveryConfigMutationVariables = Exact<{
  application: Scalars['String'];
}>;

export type ImportDeliveryConfigMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'importDeliveryConfig'>;

export type ToggleResourceManagementMutationVariables = Exact<{
  payload?: Maybe<MdToggleResourceManagementPayload>;
}>;

export type ToggleResourceManagementMutation = { __typename?: 'Mutation' } & Pick<Mutation, 'toggleResourceManagement'>;

export type RestartConstraintEvaluationMutationVariables = Exact<{
  payload: MdRestartConstraintEvaluationPayload;
}>;

export type RestartConstraintEvaluationMutation = { __typename?: 'Mutation' } & Pick<
  Mutation,
  'restartConstraintEvaluation'
>;

export const ActionDetailsFragmentDoc = gql`
  fragment actionDetails on MdAction {
    id
    actionId
    actionType
    status
    startedAt
    completedAt
    link
  }
`;
export const DetailedVersionFieldsFragmentDoc = gql`
  fragment detailedVersionFields on MdArtifactVersionInEnvironment {
    id
    buildNumber
    version
    createdAt
    status
    isCurrent
    gitMetadata {
      commit
      author
      branch
      commitInfo {
        sha
        link
        message
      }
      pullRequest {
        number
        link
      }
      comparisonLinks {
        toPreviousVersion
        toCurrentVersion
      }
    }
    deployedAt
    lifecycleSteps {
      startedAt
      completedAt
      type
      status
      link
    }
    constraints {
      type
      status
      judgedBy
      judgedAt
      attributes
    }
    verifications {
      ...actionDetails
    }
    postDeploy {
      ...actionDetails
    }
    veto {
      vetoedBy
      vetoedAt
      comment
    }
  }
  ${ActionDetailsFragmentDoc}
`;
export const ArtifactPinnedVersionFieldsFragmentDoc = gql`
  fragment artifactPinnedVersionFields on MdArtifact {
    pinnedVersion {
      id
      version
      buildNumber
      pinnedAt
      pinnedBy
      comment
      gitMetadata {
        commitInfo {
          message
        }
      }
    }
  }
`;
export const BaseEnvironmentFieldsFragmentDoc = gql`
  fragment baseEnvironmentFields on MdEnvironment {
    id
    name
    isPreview
    gitMetadata {
      branch
      pullRequest {
        link
      }
    }
    basedOn
  }
`;
export const BaesResourceFieldsFragmentDoc = gql`
  fragment baesResourceFields on MdResource {
    id
    kind
    displayName
    moniker {
      app
      stack
      detail
    }
    location {
      account
      regions
    }
    rawDefinition
  }
`;
export const FetchApplicationDocument = gql`
  query fetchApplication($appName: String!, $statuses: [MdArtifactStatusInEnvironment!]) {
    application(appName: $appName) {
      id
      name
      config {
        id
        previewEnvironmentsConfigured
      }
      environments {
        ...baseEnvironmentFields
        isDeleting
        state {
          id
          artifacts {
            id
            name
            environment
            type
            reference
            versions(statuses: $statuses) {
              ...detailedVersionFields
            }
            ...artifactPinnedVersionFields
            resources {
              ...baesResourceFields
            }
          }
          resources {
            ...baesResourceFields
          }
        }
      }
    }
  }
  ${BaseEnvironmentFieldsFragmentDoc}
  ${DetailedVersionFieldsFragmentDoc}
  ${ArtifactPinnedVersionFieldsFragmentDoc}
  ${BaesResourceFieldsFragmentDoc}
`;

/**
 * __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 function useFetchApplicationQuery(
  baseOptions: Apollo.QueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchApplicationQuery, FetchApplicationQueryVariables>(FetchApplicationDocument, options);
}
export function useFetchApplicationLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchApplicationQuery, FetchApplicationQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchApplicationQuery, FetchApplicationQueryVariables>(FetchApplicationDocument, options);
}
export type FetchApplicationQueryHookResult = ReturnType<typeof useFetchApplicationQuery>;
export type FetchApplicationLazyQueryHookResult = ReturnType<typeof useFetchApplicationLazyQuery>;
export type FetchApplicationQueryResult = Apollo.QueryResult<FetchApplicationQuery, FetchApplicationQueryVariables>;
export const FetchCurrentVersionDocument = gql`
  query fetchCurrentVersion($appName: String!) {
    application(appName: $appName) {
      id
      name
      environments {
        id
        name
        state {
          artifacts {
            id
            name
            reference
            environment
            versions(statuses: [CURRENT]) {
              id
              version
              buildNumber
              createdAt
              gitMetadata {
                commit
                commitInfo {
                  sha
                  message
                }
              }
            }
          }
        }
      }
    }
  }
`;

/**
 * __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 function useFetchCurrentVersionQuery(
  baseOptions: Apollo.QueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>(
    FetchCurrentVersionDocument,
    options,
  );
}
export function useFetchCurrentVersionLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchCurrentVersionQuery, FetchCurrentVersionQueryVariables>(
    FetchCurrentVersionDocument,
    options,
  );
}
export type FetchCurrentVersionQueryHookResult = ReturnType<typeof useFetchCurrentVersionQuery>;
export type FetchCurrentVersionLazyQueryHookResult = ReturnType<typeof useFetchCurrentVersionLazyQuery>;
export type FetchCurrentVersionQueryResult = Apollo.QueryResult<
  FetchCurrentVersionQuery,
  FetchCurrentVersionQueryVariables
>;
export const FetchVersionsHistoryDocument = gql`
  query fetchVersionsHistory($appName: String!, $limit: Int) {
    application(appName: $appName) {
      id
      name
      environments {
        ...baseEnvironmentFields
        state {
          id
          artifacts {
            id
            name
            environment
            type
            reference
            versions(limit: $limit) {
              id
              buildNumber
              version
              createdAt
              status
              isCurrent
              gitMetadata {
                commit
                author
                branch
                commitInfo {
                  sha
                  link
                  message
                }
                pullRequest {
                  number
                  link
                }
              }
            }
            ...artifactPinnedVersionFields
          }
        }
      }
    }
  }
  ${BaseEnvironmentFieldsFragmentDoc}
  ${ArtifactPinnedVersionFieldsFragmentDoc}
`;

/**
 * __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 function useFetchVersionsHistoryQuery(
  baseOptions: Apollo.QueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>(
    FetchVersionsHistoryDocument,
    options,
  );
}
export function useFetchVersionsHistoryLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchVersionsHistoryQuery, FetchVersionsHistoryQueryVariables>(
    FetchVersionsHistoryDocument,
    options,
  );
}
export type FetchVersionsHistoryQueryHookResult = ReturnType<typeof useFetchVersionsHistoryQuery>;
export type FetchVersionsHistoryLazyQueryHookResult = ReturnType<typeof useFetchVersionsHistoryLazyQuery>;
export type FetchVersionsHistoryQueryResult = Apollo.QueryResult<
  FetchVersionsHistoryQuery,
  FetchVersionsHistoryQueryVariables
>;
export const FetchPinnedVersionsDocument = gql`
  query fetchPinnedVersions($appName: String!) {
    application(appName: $appName) {
      id
      name
      account
      environments {
        id
        name
        state {
          id
          artifacts {
            id
            name
            environment
            type
            reference
            ...artifactPinnedVersionFields
          }
        }
      }
    }
  }
  ${ArtifactPinnedVersionFieldsFragmentDoc}
`;

/**
 * __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 function useFetchPinnedVersionsQuery(
  baseOptions: Apollo.QueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>(
    FetchPinnedVersionsDocument,
    options,
  );
}
export function useFetchPinnedVersionsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchPinnedVersionsQuery, FetchPinnedVersionsQueryVariables>(
    FetchPinnedVersionsDocument,
    options,
  );
}
export type FetchPinnedVersionsQueryHookResult = ReturnType<typeof useFetchPinnedVersionsQuery>;
export type FetchPinnedVersionsLazyQueryHookResult = ReturnType<typeof useFetchPinnedVersionsLazyQuery>;
export type FetchPinnedVersionsQueryResult = Apollo.QueryResult<
  FetchPinnedVersionsQuery,
  FetchPinnedVersionsQueryVariables
>;
export const FetchVersionDocument = gql`
  query fetchVersion($appName: String!, $versions: [String!]) {
    application(appName: $appName) {
      id
      name
      account
      environments {
        id
        name
        state {
          id
          artifacts {
            id
            name
            environment
            type
            reference
            versions(versions: $versions) {
              ...detailedVersionFields
            }
          }
        }
      }
    }
  }
  ${DetailedVersionFieldsFragmentDoc}
`;

/**
 * __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 function useFetchVersionQuery(
  baseOptions: Apollo.QueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchVersionQuery, FetchVersionQueryVariables>(FetchVersionDocument, options);
}
export function useFetchVersionLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchVersionQuery, FetchVersionQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchVersionQuery, FetchVersionQueryVariables>(FetchVersionDocument, options);
}
export type FetchVersionQueryHookResult = ReturnType<typeof useFetchVersionQuery>;
export type FetchVersionLazyQueryHookResult = ReturnType<typeof useFetchVersionLazyQuery>;
export type FetchVersionQueryResult = Apollo.QueryResult<FetchVersionQuery, FetchVersionQueryVariables>;
export const FetchResourceStatusDocument = gql`
  query fetchResourceStatus($appName: String!) {
    application(appName: $appName) {
      id
      name
      environments {
        id
        name
        state {
          id
          resources {
            id
            kind
            state {
              status
              reason
              event
              tasks {
                id
                name
              }
            }
          }
        }
      }
    }
  }
`;

/**
 * __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 function useFetchResourceStatusQuery(
  baseOptions: Apollo.QueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>(
    FetchResourceStatusDocument,
    options,
  );
}
export function useFetchResourceStatusLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchResourceStatusQuery, FetchResourceStatusQueryVariables>(
    FetchResourceStatusDocument,
    options,
  );
}
export type FetchResourceStatusQueryHookResult = ReturnType<typeof useFetchResourceStatusQuery>;
export type FetchResourceStatusLazyQueryHookResult = ReturnType<typeof useFetchResourceStatusLazyQuery>;
export type FetchResourceStatusQueryResult = Apollo.QueryResult<
  FetchResourceStatusQuery,
  FetchResourceStatusQueryVariables
>;
export const FetchNotificationsDocument = gql`
  query fetchNotifications($appName: String!) {
    application(appName: $appName) {
      id
      name
      notifications {
        id
        level
        message
        triggeredAt
        link
        id
      }
    }
  }
`;

/**
 * __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 function useFetchNotificationsQuery(
  baseOptions: Apollo.QueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchNotificationsQuery, FetchNotificationsQueryVariables>(
    FetchNotificationsDocument,
    options,
  );
}
export function useFetchNotificationsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<FetchNotificationsQuery, FetchNotificationsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchNotificationsQuery, FetchNotificationsQueryVariables>(
    FetchNotificationsDocument,
    options,
  );
}
export type FetchNotificationsQueryHookResult = ReturnType<typeof useFetchNotificationsQuery>;
export type FetchNotificationsLazyQueryHookResult = ReturnType<typeof useFetchNotificationsLazyQuery>;
export type FetchNotificationsQueryResult = Apollo.QueryResult<
  FetchNotificationsQuery,
  FetchNotificationsQueryVariables
>;
export const FetchApplicationManagementDataDocument = gql`
  query fetchApplicationManagementData($appName: String!) {
    application(appName: $appName) {
      id
      name
      isPaused
      config {
        id
        updatedAt
        rawConfig
        processedConfig
      }
      gitIntegration {
        id
        repository
        branch
        isEnabled
        link
        manifestPath
      }
    }
  }
`;

/**
 * __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 function useFetchApplicationManagementDataQuery(
  baseOptions: Apollo.QueryHookOptions<
    FetchApplicationManagementDataQuery,
    FetchApplicationManagementDataQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>(
    FetchApplicationManagementDataDocument,
    options,
  );
}
export function useFetchApplicationManagementDataLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    FetchApplicationManagementDataQuery,
    FetchApplicationManagementDataQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchApplicationManagementDataQuery, FetchApplicationManagementDataQueryVariables>(
    FetchApplicationManagementDataDocument,
    options,
  );
}
export type FetchApplicationManagementDataQueryHookResult = ReturnType<typeof useFetchApplicationManagementDataQuery>;
export type FetchApplicationManagementDataLazyQueryHookResult = ReturnType<
  typeof useFetchApplicationManagementDataLazyQuery
>;
export type FetchApplicationManagementDataQueryResult = Apollo.QueryResult<
  FetchApplicationManagementDataQuery,
  FetchApplicationManagementDataQueryVariables
>;
export const FetchApplicationManagementStatusDocument = gql`
  query fetchApplicationManagementStatus($appName: String!) {
    application(appName: $appName) {
      id
      name
      isPaused
    }
  }
`;

/**
 * __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 function useFetchApplicationManagementStatusQuery(
  baseOptions: Apollo.QueryHookOptions<
    FetchApplicationManagementStatusQuery,
    FetchApplicationManagementStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>(
    FetchApplicationManagementStatusDocument,
    options,
  );
}
export function useFetchApplicationManagementStatusLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    FetchApplicationManagementStatusQuery,
    FetchApplicationManagementStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<FetchApplicationManagementStatusQuery, FetchApplicationManagementStatusQueryVariables>(
    FetchApplicationManagementStatusDocument,
    options,
  );
}
export type FetchApplicationManagementStatusQueryHookResult = ReturnType<
  typeof useFetchApplicationManagementStatusQuery
>;
export type FetchApplicationManagementStatusLazyQueryHookResult = ReturnType<
  typeof useFetchApplicationManagementStatusLazyQuery
>;
export type FetchApplicationManagementStatusQueryResult = Apollo.QueryResult<
  FetchApplicationManagementStatusQuery,
  FetchApplicationManagementStatusQueryVariables
>;
export const UpdateConstraintDocument = gql`
  mutation UpdateConstraint($payload: MdConstraintStatusPayload!) {
    updateConstraintStatus(payload: $payload)
  }
`;
export 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 function useUpdateConstraintMutation(
  baseOptions?: Apollo.MutationHookOptions<UpdateConstraintMutation, UpdateConstraintMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<UpdateConstraintMutation, UpdateConstraintMutationVariables>(
    UpdateConstraintDocument,
    options,
  );
}
export type UpdateConstraintMutationHookResult = ReturnType<typeof useUpdateConstraintMutation>;
export type UpdateConstraintMutationResult = Apollo.MutationResult<UpdateConstraintMutation>;
export type UpdateConstraintMutationOptions = Apollo.BaseMutationOptions<
  UpdateConstraintMutation,
  UpdateConstraintMutationVariables
>;
export const ToggleManagementDocument = gql`
  mutation ToggleManagement($application: ID!, $isPaused: Boolean!) {
    toggleManagement(application: $application, isPaused: $isPaused)
  }
`;
export 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 function useToggleManagementMutation(
  baseOptions?: Apollo.MutationHookOptions<ToggleManagementMutation, ToggleManagementMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<ToggleManagementMutation, ToggleManagementMutationVariables>(
    ToggleManagementDocument,
    options,
  );
}
export type ToggleManagementMutationHookResult = ReturnType<typeof useToggleManagementMutation>;
export type ToggleManagementMutationResult = Apollo.MutationResult<ToggleManagementMutation>;
export type ToggleManagementMutationOptions = Apollo.BaseMutationOptions<
  ToggleManagementMutation,
  ToggleManagementMutationVariables
>;
export const PinVersionDocument = gql`
  mutation PinVersion($payload: MdArtifactVersionActionPayload!) {
    pinArtifactVersion(payload: $payload)
  }
`;
export 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 function usePinVersionMutation(
  baseOptions?: Apollo.MutationHookOptions<PinVersionMutation, PinVersionMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<PinVersionMutation, PinVersionMutationVariables>(PinVersionDocument, options);
}
export type PinVersionMutationHookResult = ReturnType<typeof usePinVersionMutation>;
export type PinVersionMutationResult = Apollo.MutationResult<PinVersionMutation>;
export type PinVersionMutationOptions = Apollo.BaseMutationOptions<PinVersionMutation, PinVersionMutationVariables>;
export const UnpinVersionDocument = gql`
  mutation UnpinVersion($payload: MdUnpinArtifactVersionPayload!) {
    unpinArtifactVersion(payload: $payload)
  }
`;
export 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 function useUnpinVersionMutation(
  baseOptions?: Apollo.MutationHookOptions<UnpinVersionMutation, UnpinVersionMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<UnpinVersionMutation, UnpinVersionMutationVariables>(UnpinVersionDocument, options);
}
export type UnpinVersionMutationHookResult = ReturnType<typeof useUnpinVersionMutation>;
export type UnpinVersionMutationResult = Apollo.MutationResult<UnpinVersionMutation>;
export type UnpinVersionMutationOptions = Apollo.BaseMutationOptions<
  UnpinVersionMutation,
  UnpinVersionMutationVariables
>;
export const MarkVersionAsBadDocument = gql`
  mutation MarkVersionAsBad($payload: MdArtifactVersionActionPayload!) {
    markArtifactVersionAsBad(payload: $payload)
  }
`;
export 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 function useMarkVersionAsBadMutation(
  baseOptions?: Apollo.MutationHookOptions<MarkVersionAsBadMutation, MarkVersionAsBadMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<MarkVersionAsBadMutation, MarkVersionAsBadMutationVariables>(
    MarkVersionAsBadDocument,
    options,
  );
}
export type MarkVersionAsBadMutationHookResult = ReturnType<typeof useMarkVersionAsBadMutation>;
export type MarkVersionAsBadMutationResult = Apollo.MutationResult<MarkVersionAsBadMutation>;
export type MarkVersionAsBadMutationOptions = Apollo.BaseMutationOptions<
  MarkVersionAsBadMutation,
  MarkVersionAsBadMutationVariables
>;
export const MarkVersionAsGoodDocument = gql`
  mutation MarkVersionAsGood($payload: MdMarkArtifactVersionAsGoodPayload!) {
    markArtifactVersionAsGood(payload: $payload)
  }
`;
export 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 function useMarkVersionAsGoodMutation(
  baseOptions?: Apollo.MutationHookOptions<MarkVersionAsGoodMutation, MarkVersionAsGoodMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<MarkVersionAsGoodMutation, MarkVersionAsGoodMutationVariables>(
    MarkVersionAsGoodDocument,
    options,
  );
}
export type MarkVersionAsGoodMutationHookResult = ReturnType<typeof useMarkVersionAsGoodMutation>;
export type MarkVersionAsGoodMutationResult = Apollo.MutationResult<MarkVersionAsGoodMutation>;
export type MarkVersionAsGoodMutationOptions = Apollo.BaseMutationOptions<
  MarkVersionAsGoodMutation,
  MarkVersionAsGoodMutationVariables
>;
export const RetryVersionActionDocument = gql`
  mutation RetryVersionAction($payload: MdRetryArtifactActionPayload!) {
    retryArtifactVersionAction(payload: $payload) {
      ...actionDetails
    }
  }
  ${ActionDetailsFragmentDoc}
`;
export 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 function useRetryVersionActionMutation(
  baseOptions?: Apollo.MutationHookOptions<RetryVersionActionMutation, RetryVersionActionMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<RetryVersionActionMutation, RetryVersionActionMutationVariables>(
    RetryVersionActionDocument,
    options,
  );
}
export type RetryVersionActionMutationHookResult = ReturnType<typeof useRetryVersionActionMutation>;
export type RetryVersionActionMutationResult = Apollo.MutationResult<RetryVersionActionMutation>;
export type RetryVersionActionMutationOptions = Apollo.BaseMutationOptions<
  RetryVersionActionMutation,
  RetryVersionActionMutationVariables
>;
export const UpdateGitIntegrationDocument = gql`
  mutation UpdateGitIntegration($payload: MdUpdateGitIntegrationPayload!) {
    updateGitIntegration(payload: $payload) {
      id
      isEnabled
    }
  }
`;
export 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 function useUpdateGitIntegrationMutation(
  baseOptions?: Apollo.MutationHookOptions<UpdateGitIntegrationMutation, UpdateGitIntegrationMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<UpdateGitIntegrationMutation, UpdateGitIntegrationMutationVariables>(
    UpdateGitIntegrationDocument,
    options,
  );
}
export type UpdateGitIntegrationMutationHookResult = ReturnType<typeof useUpdateGitIntegrationMutation>;
export type UpdateGitIntegrationMutationResult = Apollo.MutationResult<UpdateGitIntegrationMutation>;
export type UpdateGitIntegrationMutationOptions = Apollo.BaseMutationOptions<
  UpdateGitIntegrationMutation,
  UpdateGitIntegrationMutationVariables
>;
export const DismissNotificationDocument = gql`
  mutation DismissNotification($payload: MdDismissNotificationPayload!) {
    dismissNotification(payload: $payload)
  }
`;
export 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 function useDismissNotificationMutation(
  baseOptions?: Apollo.MutationHookOptions<DismissNotificationMutation, DismissNotificationMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<DismissNotificationMutation, DismissNotificationMutationVariables>(
    DismissNotificationDocument,
    options,
  );
}
export type DismissNotificationMutationHookResult = ReturnType<typeof useDismissNotificationMutation>;
export type DismissNotificationMutationResult = Apollo.MutationResult<DismissNotificationMutation>;
export type DismissNotificationMutationOptions = Apollo.BaseMutationOptions<
  DismissNotificationMutation,
  DismissNotificationMutationVariables
>;
export const ImportDeliveryConfigDocument = gql`
  mutation ImportDeliveryConfig($application: String!) {
    importDeliveryConfig(application: $application)
  }
`;
export 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 function useImportDeliveryConfigMutation(
  baseOptions?: Apollo.MutationHookOptions<ImportDeliveryConfigMutation, ImportDeliveryConfigMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<ImportDeliveryConfigMutation, ImportDeliveryConfigMutationVariables>(
    ImportDeliveryConfigDocument,
    options,
  );
}
export type ImportDeliveryConfigMutationHookResult = ReturnType<typeof useImportDeliveryConfigMutation>;
export type ImportDeliveryConfigMutationResult = Apollo.MutationResult<ImportDeliveryConfigMutation>;
export type ImportDeliveryConfigMutationOptions = Apollo.BaseMutationOptions<
  ImportDeliveryConfigMutation,
  ImportDeliveryConfigMutationVariables
>;
export const ToggleResourceManagementDocument = gql`
  mutation ToggleResourceManagement($payload: MdToggleResourceManagementPayload) {
    toggleResourceManagement(payload: $payload)
  }
`;
export 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 function useToggleResourceManagementMutation(
  baseOptions?: Apollo.MutationHookOptions<ToggleResourceManagementMutation, ToggleResourceManagementMutationVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<ToggleResourceManagementMutation, ToggleResourceManagementMutationVariables>(
    ToggleResourceManagementDocument,
    options,
  );
}
export type ToggleResourceManagementMutationHookResult = ReturnType<typeof useToggleResourceManagementMutation>;
export type ToggleResourceManagementMutationResult = Apollo.MutationResult<ToggleResourceManagementMutation>;
export type ToggleResourceManagementMutationOptions = Apollo.BaseMutationOptions<
  ToggleResourceManagementMutation,
  ToggleResourceManagementMutationVariables
>;
export const RestartConstraintEvaluationDocument = gql`
  mutation RestartConstraintEvaluation($payload: MdRestartConstraintEvaluationPayload!) {
    restartConstraintEvaluation(payload: $payload)
  }
`;
export 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 function useRestartConstraintEvaluationMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RestartConstraintEvaluationMutation,
    RestartConstraintEvaluationMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<RestartConstraintEvaluationMutation, RestartConstraintEvaluationMutationVariables>(
    RestartConstraintEvaluationDocument,
    options,
  );
}
export type RestartConstraintEvaluationMutationHookResult = ReturnType<typeof useRestartConstraintEvaluationMutation>;
export type RestartConstraintEvaluationMutationResult = Apollo.MutationResult<RestartConstraintEvaluationMutation>;
export type RestartConstraintEvaluationMutationOptions = Apollo.BaseMutationOptions<
  RestartConstraintEvaluationMutation,
  RestartConstraintEvaluationMutationVariables
>;