/* tslint:disable */
import { URI } from '@vscode-alt/monaco-editor/esm/vs/base/common/uri';
import { Severity as INotificationSeverity } from '../../core/severity';
import { ConfigurationTarget as IConfigurationTarget } from '../configuration';
import { ConfigurationScope } from '../configuration';
import { ConfigurationTarget } from '../configuration';
import { EditorOpenPositioning } from '../enum';
import { GroupDirection } from '../enum';
import { GroupLocation } from '../enum';
import { GroupOrientation } from '../enum';
import { MergeGroupMode } from '../enum';
import { CloseDirection } from '../enum';
import { GroupsOrder } from '../enum';
import { Severity } from '../../core/severity';
import NotificationSeverity = Severity;
import { EditorsOrder } from '../enum';
import { GroupsArrangement } from '../enum';
import { LableFormatType } from '../enum';
import { OpenSideBySideDirection } from '../enum';
import { OpenPositioningType } from '../enum';
import { TabSizingType } from '../enum';
import { TabCloseButtonType } from '../enum';
import { SideBySideEditor } from '../enum';
import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
import { ApolloContext } from '../apollo-context';
import { gql } from '@apollo/client/index.js';
import * as Apollo from '@apollo/client/index.js';
export type Maybe<T> = T | null;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
export type EnumResolverSignature<T, AllowedValues = any> = { [key in keyof T]?: AllowedValues };
export type RequireFields<T, K extends keyof T> = { [X in Exclude<keyof T, K>]?: T[X] } & { [P in K]-?: NonNullable<T[P]> };
const defaultOptions =  {}
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  AnyObject: any;
  BigInt: any;
  Date: any;
  DateTime: any;
  JSON: any;
  JSONObject: any;
  Observable: any;
  Time: any;
  URI: URI;
  URIInput: any;
  VSBuffer: any;
  VSBufferReadableStream: any;
};


export type IAction = {
  __typename?: 'Action';
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  tooltip?: Maybe<Scalars['String']>;
  class?: Maybe<Scalars['String']>;
  enabled?: Maybe<Scalars['Boolean']>;
  checked?: Maybe<Scalars['Boolean']>;
  radio?: Maybe<Scalars['Boolean']>;
  run?: Maybe<IActionRun>;
};

export type IActionInput = {
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  tooltip?: Maybe<Scalars['String']>;
  class?: Maybe<Scalars['String']>;
  enabled?: Maybe<Scalars['Boolean']>;
  checked?: Maybe<Scalars['Boolean']>;
  radio?: Maybe<Scalars['Boolean']>;
  run?: Maybe<IActionRunInput>;
};

export type IActionItem = {
  __typename?: 'ActionItem';
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
};

export type IActionRun = {
  __typename?: 'ActionRun';
  type?: Maybe<IGraphqlCallType>;
  document?: Maybe<Scalars['AnyObject']>;
  variables?: Maybe<Scalars['AnyObject']>;
};

export type IActionRunInput = {
  type?: Maybe<IGraphqlCallType>;
  document?: Maybe<Scalars['AnyObject']>;
  variables?: Maybe<Scalars['AnyObject']>;
};

export type IActions = {
  __typename?: 'Actions';
  id?: Maybe<Scalars['String']>;
  command?: Maybe<Scalars['String']>;
  title?: Maybe<Scalars['String']>;
  category?: Maybe<Scalars['String']>;
  actionItem?: Maybe<IActionItem>;
};

export type IAddEntryInput = {
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<Scalars['String']>;
  entry?: Maybe<IStatusbarEntryInput>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
};

export type IAddFoldersRequest = {
  __typename?: 'AddFoldersRequest';
  foldersToAdd?: Maybe<Array<Maybe<Scalars['URI']>>>;
};

export type IAddGroupOptions_Input = {
  activate?: Maybe<Scalars['Boolean']>;
};

export type IAdminIdeSettings = {
  __typename?: 'AdminIdeSettings';
  dummy?: Maybe<Scalars['Int']>;
};

export type IAnchor = {
  __typename?: 'Anchor';
  x?: Maybe<Scalars['Int']>;
  y?: Maybe<Scalars['Int']>;
  height?: Maybe<Scalars['Int']>;
  width?: Maybe<Scalars['Int']>;
};

export type IAnchorInput = {
  x?: Maybe<Scalars['Int']>;
  y?: Maybe<Scalars['Int']>;
  height?: Maybe<Scalars['Int']>;
  width?: Maybe<Scalars['Int']>;
};


export type IArg_Input = {
  id?: Maybe<Scalars['String']>;
  folderUri?: Maybe<Scalars['URI']>;
};

export type IArgsInput = {
  id?: Maybe<Scalars['String']>;
  folderUri?: Maybe<Scalars['URI']>;
};

export type IArgsType = {
  __typename?: 'ArgsType';
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  constraint?: Maybe<Scalars['String']>;
};

export type IAssets = {
  __typename?: 'Assets';
  Type?: Maybe<Scalars['String']>;
  Content?: Maybe<Scalars['String']>;
};

export type IAuthor = {
  __typename?: 'Author';
  name?: Maybe<Scalars['String']>;
};

export const enum IAutoSaveConfigurationType {
  Off = 'off',
  AfterDelay = 'afterDelay',
  OnFocusChange = 'onFocusChange',
  OnWindowChange = 'onWindowChange'
};

export type IBaseExtension = {
  __typename?: 'BaseExtension';
  type?: Maybe<IExtensionType>;
  identifier?: Maybe<IExtensionIdentifier>;
  /** @deprecated */
  galleryIdentifier?: Maybe<IExtensionIdentifier>;
  manifest?: Maybe<IExtensionManifest>;
  location?: Maybe<Scalars['URI']>;
};

/**
 * Type of input will help to determine what type of editor to be opened in.
 * Varaious Input have following common fields.
 */
export type IBaseResourceInput = {
  /** Optional options to use when opening the text input. */
  options?: Maybe<ITextEditorOptions_Input>;
  /** Label to show for the diff editor */
  label?: Maybe<Scalars['String']>;
  /** Description to show for the diff editor */
  description?: Maybe<Scalars['String']>;
  /**
   * Hint to indicate that this input should be treated as a file
   * that opens in an editor capable of showing file content.
   *
   * Without this hint, the editor service will make a guess by
   * looking at the scheme of the resource(s).
   */
  forceFile?: Maybe<Scalars['Boolean']>;
  /**
   * Hint to indicate that this input should be treated as a
   * untitled file
   *
   * Without this hint, the editor service will make a guess by
   * looking at the scheme of the resource(s).
   */
  forceUntitled?: Maybe<Scalars['Boolean']>;
};


export type IBranchStatus = IIStatusbarItem & {
  __typename?: 'BranchStatus';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type IBundles = {
  __typename?: 'Bundles';
  server?: Maybe<Scalars['String']>;
  browser?: Maybe<Scalars['String']>;
};

export const enum ICacheControlScope {
  Public = 'PUBLIC',
  Private = 'PRIVATE'
};

export type ICachedSearchStats = {
  __typename?: 'CachedSearchStats';
  cacheWasResolved?: Maybe<Scalars['Boolean']>;
  cacheLookupTime?: Maybe<Scalars['Int']>;
  cacheFilterTime?: Maybe<Scalars['Int']>;
  cacheEntryCount?: Maybe<Scalars['Int']>;
};

export type IChangeRange = {
  __typename?: 'ChangeRange';
  startLineNumber?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  endLineNumber?: Maybe<Scalars['Int']>;
  endColumn?: Maybe<Scalars['Int']>;
};

export type IChangeRange_Input = {
  startLineNumber?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  endLineNumber?: Maybe<Scalars['Int']>;
  endColumn?: Maybe<Scalars['Int']>;
};

export type IChangesChangesChunk_Input = {
  range?: Maybe<IChangeRange_Input>;
  rangeLength?: Maybe<Scalars['Int']>;
  text?: Maybe<Scalars['String']>;
  part?: Maybe<Scalars['Int']>;
};

export type IChangesChunk = {
  __typename?: 'ChangesChunk';
  range?: Maybe<IChangeRange>;
  rangeLength?: Maybe<Scalars['Int']>;
  text?: Maybe<Scalars['String']>;
  rangeOffset?: Maybe<Scalars['Int']>;
  forceMoveMarkers?: Maybe<Scalars['Boolean']>;
};

export type IChangesChunk_Input = {
  range?: Maybe<IChangeRange_Input>;
  rangeLength?: Maybe<Scalars['Int']>;
  text?: Maybe<Scalars['String']>;
  rangeOffset?: Maybe<Scalars['Int']>;
  forceMoveMarkers?: Maybe<Scalars['Boolean']>;
};

export type ICheckboxOptions = {
  __typename?: 'CheckboxOptions';
  label?: Maybe<Scalars['String']>;
  checked?: Maybe<Scalars['Boolean']>;
};

export type ICheckboxOptionsInput = {
  label?: Maybe<Scalars['String']>;
  checked?: Maybe<Scalars['Boolean']>;
};

export type IChunkOptions_Input = {
  piece?: Maybe<IChangesChangesChunk_Input>;
  chunksCount?: Maybe<Scalars['Int']>;
  chunkPosition?: Maybe<Scalars['Int']>;
};

export { CloseDirection };

export type ICloseEditorOptions_Input = {
  preserveFocus?: Maybe<Scalars['Boolean']>;
};

export type ICloseEditor_Input = {
  resource: Scalars['String'];
  editorId?: Maybe<Scalars['Int']>;
  name?: Maybe<Scalars['String']>;
};

export type ICloseEditorsFilter = {
  __typename?: 'CloseEditorsFilter';
  except?: Maybe<IEditorInput>;
  direction?: Maybe<CloseDirection>;
  savedOnly?: Maybe<Scalars['Boolean']>;
};

/** Extension of CloseEditorOptions_Input */
export type ICloseOptions_Input = {
  preserveFocus?: Maybe<Scalars['Boolean']>;
  closeEmptyGroups?: Maybe<Scalars['Boolean']>;
};

export type ICodeEditorViewState = {
  __typename?: 'CodeEditorViewState';
  cursorState?: Maybe<Scalars['JSON']>;
  viewState?: Maybe<Scalars['JSON']>;
  contributionsState?: Maybe<Scalars['JSON']>;
};

export type ICodeEditorViewState_Input = {
  cursorState?: Maybe<Scalars['JSON']>;
  viewState?: Maybe<Scalars['JSON']>;
  contributionsState?: Maybe<Scalars['JSON']>;
};

export type ICommandHandlerDescriptionType = {
  __typename?: 'CommandHandlerDescriptionType';
  description?: Maybe<Scalars['String']>;
  args?: Maybe<Array<Maybe<IArgsType>>>;
  returns?: Maybe<Scalars['String']>;
};

export type ICommandType = {
  __typename?: 'CommandType';
  id?: Maybe<Scalars['String']>;
  handler?: Maybe<Scalars['AnyObject']>;
  description?: Maybe<ICommandHandlerDescriptionType>;
};

export type ICommandsType = {
  __typename?: 'CommandsType';
  commands?: Maybe<Array<Maybe<ICommandType>>>;
};

export type IConfiguration = {
  __typename?: 'Configuration';
  defaultSetting?: Maybe<Array<Maybe<ISettingsGroup>>>;
  files?: Maybe<IFiles>;
  git?: Maybe<IGit>;
  languages?: Maybe<ILanguages>;
  output?: Maybe<IOutput>;
  search?: Maybe<ISearch>;
  terminal?: Maybe<ITerminal>;
  workspace?: Maybe<IWorkspacePreferenceWorkbench>;
};

export type IConfigurationData = {
  __typename?: 'ConfigurationData';
  defaults?: Maybe<IConfigurationModel>;
  user?: Maybe<IConfigurationModel>;
  workspace?: Maybe<IConfigurationModel>;
  folders?: Maybe<Array<Maybe<IFolderConfigurationModel>>>;
  isComplete?: Maybe<Scalars['Boolean']>;
};

export type IConfigurationExtensionInfo = {
  __typename?: 'ConfigurationExtensionInfo';
  id?: Maybe<Scalars['String']>;
};

export type IConfigurationModel = {
  __typename?: 'ConfigurationModel';
  contents?: Maybe<Scalars['AnyObject']>;
  keys?: Maybe<Array<Maybe<Scalars['String']>>>;
  overrides?: Maybe<Array<Maybe<IOverrides>>>;
};

export type IConfigurationOverrides = {
  __typename?: 'ConfigurationOverrides';
  resource?: Maybe<Scalars['URI']>;
  overrideIdentifier?: Maybe<Scalars['String']>;
};

export type IConfigurationOverrides_Input = {
  resource?: Maybe<Scalars['URI']>;
  overrideIdentifier?: Maybe<Scalars['String']>;
};

export { ConfigurationScope };

export const enum IConfigurationServiceAction {
  GetConfigurationData = 'getConfigurationData',
  ReloadConfiguration = 'reloadConfiguration',
  OnDidChangeConfiguration = 'onDidChangeConfiguration',
  UpdateValue = 'updateValue'
};

export { ConfigurationTarget };

export type IContentChangedEvent = {
  __typename?: 'ContentChangedEvent';
  changes?: Maybe<Array<Maybe<IChangesChunk>>>;
  eol?: Maybe<Scalars['String']>;
  versionId?: Maybe<Scalars['Int']>;
  isUndoing?: Maybe<Scalars['Boolean']>;
  isRedoing?: Maybe<Scalars['Boolean']>;
  isFlush?: Maybe<Scalars['Boolean']>;
};

export type IContentChangedEvent_Input = {
  changes?: Maybe<Array<Maybe<IChangesChunk_Input>>>;
  eol?: Maybe<Scalars['String']>;
  versionId?: Maybe<Scalars['Int']>;
  isUndoing?: Maybe<Scalars['Boolean']>;
  isRedoing?: Maybe<Scalars['Boolean']>;
  isFlush?: Maybe<Scalars['Boolean']>;
};

export type IContext = {
  __typename?: 'Context';
  originalResourceScheme?: Maybe<IScmResourceGroups>;
  view?: Maybe<Scalars['String']>;
  viewItem?: Maybe<Scalars['String']>;
  gitOpenRepositoryCount?: Maybe<Scalars['Int']>;
  isInDiffEditor?: Maybe<Scalars['Boolean']>;
  isInDiffRightEditor?: Maybe<Scalars['Boolean']>;
  resourceScheme?: Maybe<Scalars['String']>;
  resourceFilename?: Maybe<Scalars['String']>;
  resourceLangId?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['URI']>;
  resourceExtName?: Maybe<Scalars['String']>;
  resourceSet?: Maybe<Scalars['Boolean']>;
  isFileSystemResource?: Maybe<Scalars['Boolean']>;
  inputFocus?: Maybe<Scalars['Boolean']>;
  suggestWidgetVisible?: Maybe<Scalars['Boolean']>;
  suggestWidgetMultipleSuggestions?: Maybe<Scalars['Boolean']>;
  suggestionMakesTextEdit?: Maybe<Scalars['Boolean']>;
  acceptSuggestionOnEnter?: Maybe<Scalars['Boolean']>;
  hasOtherSuggestions?: Maybe<Scalars['Boolean']>;
  groupFocusedInOpenEditors?: Maybe<Scalars['Boolean']>;
  dirtyEditor?: Maybe<Scalars['Boolean']>;
  resourceSelectedForCompare?: Maybe<Scalars['Boolean']>;
  fileCopied?: Maybe<Scalars['Boolean']>;
  breadcrumbsPossible?: Maybe<Scalars['Boolean']>;
  breadcrumbsVisible?: Maybe<Scalars['Boolean']>;
  breadcrumbsActive?: Maybe<Scalars['Boolean']>;
  canNavigateBack?: Maybe<Scalars['Boolean']>;
  canNavigateForward?: Maybe<Scalars['Boolean']>;
  canNavigateToLastEditLocation?: Maybe<Scalars['Boolean']>;
  dirtyDiffVisible?: Maybe<Scalars['Boolean']>;
  cancellableOperation?: Maybe<Scalars['Boolean']>;
  parameterHintsVisible?: Maybe<Scalars['Boolean']>;
  parameterHintsMultipleSignatures?: Maybe<Scalars['Boolean']>;
  markdownPreviewFocus?: Maybe<Scalars['Boolean']>;
  isMac?: Maybe<Scalars['Boolean']>;
  isLinux?: Maybe<Scalars['Boolean']>;
  isWindows?: Maybe<Scalars['Boolean']>;
  remoteAuthority?: Maybe<Scalars['String']>;
  remoteConnectionState?: Maybe<IProvidedRemoteConnectionStates>;
  hasMacNativeTabs?: Maybe<Scalars['Boolean']>;
  supportsWorkspaces?: Maybe<Scalars['Boolean']>;
  isDevelopment?: Maybe<Scalars['Boolean']>;
  workbenchState?: Maybe<Scalars['String']>;
  workspaceFolderCount?: Maybe<Scalars['Int']>;
  remoteFileDialogVisible?: Maybe<Scalars['Boolean']>;
  isFullscreen?: Maybe<Scalars['Boolean']>;
  atEndOfWord?: Maybe<Scalars['Boolean']>;
  scmRepository?: Maybe<Scalars['String']>;
  scmProvider?: Maybe<Scalars['String']>;
  scmResourceGroup?: Maybe<IScmResourceGroups>;
  inDiffEditorKey?: Maybe<Scalars['Boolean']>;
  isDominatedByLongLines?: Maybe<Scalars['Boolean']>;
  isWordWrapMinified?: Maybe<Scalars['Boolean']>;
  commentThread?: Maybe<Scalars['String']>;
  commentThreadisEmpty?: Maybe<Scalars['Boolean']>;
  commentIsEmpty?: Maybe<Scalars['Boolean']>;
  commentEditorFocused?: Maybe<Scalars['Boolean']>;
  interfaceOverviewVisible?: Maybe<Scalars['Boolean']>;
  inReferenceSearchEditor?: Maybe<Scalars['Boolean']>;
  referenceSearchVisible?: Maybe<Scalars['Boolean']>;
  listFocus?: Maybe<Scalars['Boolean']>;
  listSupportsMultiSelect?: Maybe<Scalars['Boolean']>;
  listHasSelectionOrFocus?: Maybe<Scalars['Boolean']>;
  listDoubleSelection?: Maybe<Scalars['Boolean']>;
  listMultiSelection?: Maybe<Scalars['Boolean']>;
  listSupportsKeyboardNavigation?: Maybe<Scalars['Boolean']>;
  WorkbenchListAutomaticKeyboardNavigationKey?: Maybe<Scalars['Boolean']>;
  accessibilityHelpWidgetVisible?: Maybe<Scalars['Boolean']>;
  inQuickOpenKey?: Maybe<Scalars['Boolean']>;
  supportedCodeAction?: Maybe<Scalars['String']>;
  hasSymbols?: Maybe<Scalars['Boolean']>;
  hasSnippetCompletions?: Maybe<Scalars['Boolean']>;
  messageVisible?: Maybe<Scalars['Boolean']>;
  editorHasCallHierarchyProvider?: Maybe<Scalars['Boolean']>;
  callHierarchyVisible?: Maybe<Scalars['Boolean']>;
  searchViewletVisible?: Maybe<Scalars['Boolean']>;
  searchViewletFocus?: Maybe<Scalars['Boolean']>;
  inputBoxFocus?: Maybe<Scalars['Boolean']>;
  searchInputBoxFocus?: Maybe<Scalars['Boolean']>;
  replaceInputBoxFocus?: Maybe<Scalars['Boolean']>;
  patternIncludesInputBoxFocus?: Maybe<Scalars['Boolean']>;
  patternExcludesInputBoxFocus?: Maybe<Scalars['Boolean']>;
  replaceActive?: Maybe<Scalars['Boolean']>;
  hasSearchResult?: Maybe<Scalars['Boolean']>;
  firstMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchOrMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchOrFolderMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchFocus?: Maybe<Scalars['Boolean']>;
  folderMatchFocus?: Maybe<Scalars['Boolean']>;
  matchFocus?: Maybe<Scalars['Boolean']>;
  inRecentFilesPicker?: Maybe<Scalars['Boolean']>;
  inWindowsPicker?: Maybe<Scalars['Boolean']>;
  findWidgetVisible?: Maybe<Scalars['Boolean']>;
  findInputFocussed?: Maybe<Scalars['Boolean']>;
  replaceInputFocussed?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the editor's text has focus (cursor is blinking). */
  editorTextFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the editor's text or an editor's widget has focus. */
  editorFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when any editor input has focus (regular editor, repl input...). */
  textInputFocus?: Maybe<Scalars['Boolean']>;
  editorReadonly?: Maybe<Scalars['Boolean']>;
  editorHasSelection?: Maybe<Scalars['Boolean']>;
  editorHasMultipleSelections?: Maybe<Scalars['Boolean']>;
  editorTabMoveFocus?: Maybe<Scalars['Boolean']>;
  isInEmbeddedEditor?: Maybe<Scalars['Boolean']>;
  canUndo?: Maybe<Scalars['Boolean']>;
  canRedo?: Maybe<Scalars['Boolean']>;
  editorLangId?: Maybe<Scalars['String']>;
  editorHasCompletionItemProvider?: Maybe<Scalars['Boolean']>;
  editorHasCodeActionsProvider?: Maybe<Scalars['Boolean']>;
  editorHasDefinitionProvider?: Maybe<Scalars['Boolean']>;
  editorHasDeclarationProvider?: Maybe<Scalars['Boolean']>;
  editorHasImplementationProvider?: Maybe<Scalars['Boolean']>;
  editorHasTypeDefinitionProvider?: Maybe<Scalars['Boolean']>;
  editorHasHoverProvider?: Maybe<Scalars['Boolean']>;
  editorHadDocumentHighlightProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentSymbolProvider?: Maybe<Scalars['Boolean']>;
  editorHasReferenceProvider?: Maybe<Scalars['Boolean']>;
  editorHasRenameProvider?: Maybe<Scalars['Boolean']>;
  editorHasSignatureHelpProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentFormattingProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentSelectionFormattingProvider?: Maybe<Scalars['Boolean']>;
  editorHasMultipleDocumentSelectionFormattingProvider?: Maybe<Scalars['Boolean']>;
  activeEditor?: Maybe<Scalars['String']>;
  editorIsOpen?: Maybe<Scalars['Boolean']>;
  editorPinned?: Maybe<Scalars['Boolean']>;
  groupActiveEditorDirty?: Maybe<Scalars['Boolean']>;
  groupEditorsCount?: Maybe<Scalars['Int']>;
  textCompareEditorVisible?: Maybe<Scalars['Boolean']>;
  textCompareEditorActive?: Maybe<Scalars['Boolean']>;
  activeEditorGroupEmpty?: Maybe<Scalars['Boolean']>;
  multipleEditorGroups?: Maybe<Scalars['Boolean']>;
  inZenMode?: Maybe<Scalars['Boolean']>;
  inCenteredLayout?: Maybe<Scalars['Boolean']>;
  splitEditorsVertically?: Maybe<Scalars['Boolean']>;
  sideBarVisible?: Maybe<Scalars['Boolean']>;
  sideBarFocus?: Maybe<Scalars['Boolean']>;
  activeViewlet?: Maybe<Scalars['String']>;
  activePanel?: Maybe<Scalars['String']>;
  panelFocus?: Maybe<Scalars['Boolean']>;
  panelPosition?: Maybe<Scalars['String']>;
  debugType?: Maybe<Scalars['String']>;
  debugConfigurationType?: Maybe<Scalars['String']>;
  debugState?: Maybe<Scalars['String']>;
  inDebugMode?: Maybe<Scalars['Boolean']>;
  inDebugRepl?: Maybe<Scalars['Boolean']>;
  breakpointWidgetVisible?: Maybe<Scalars['Boolean']>;
  watchExpressionsFocused?: Maybe<Scalars['Boolean']>;
  variablesFocused?: Maybe<Scalars['Boolean']>;
  expressionSelected?: Maybe<Scalars['Boolean']>;
  breakpointSelected?: Maybe<Scalars['Boolean']>;
  callStackItemType?: Maybe<Scalars['Boolean']>;
  loadedScriptsSupported?: Maybe<Scalars['Boolean']>;
  loadedScriptsItemType?: Maybe<Scalars['Boolean']>;
  focusedSessionIsAttach?: Maybe<Scalars['Boolean']>;
  stepBackSupported?: Maybe<Scalars['Boolean']>;
  restartFrameSupported?: Maybe<Scalars['Boolean']>;
  inSettingsEditor?: Maybe<Scalars['Boolean']>;
  inSettingsJSONEditor?: Maybe<Scalars['Boolean']>;
  inSettingsSearch?: Maybe<Scalars['Boolean']>;
  settingsTocRowFocus?: Maybe<Scalars['Boolean']>;
  inKeybindings?: Maybe<Scalars['Boolean']>;
  inKeybindingsSearch?: Maybe<Scalars['Boolean']>;
  keybindingFocus?: Maybe<Scalars['Boolean']>;
  explorerViewletVisible?: Maybe<Scalars['Boolean']>;
  explorerResourceIsFolder?: Maybe<Scalars['Boolean']>;
  explorerResourceReadonly?: Maybe<Scalars['Boolean']>;
  explorerResourceIsRoot?: Maybe<Scalars['Boolean']>;
  explorerResourceCut?: Maybe<Scalars['Boolean']>;
  explorerResourceMoveableToTrash?: Maybe<Scalars['Boolean']>;
  filesExplorerFocus?: Maybe<Scalars['Boolean']>;
  openEditorsVisible?: Maybe<Scalars['Boolean']>;
  openEditorsFocus?: Maybe<Scalars['Boolean']>;
  explorerViewletFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when there is at least one opened integrated terminal. */
  terminalIsOpen?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the integrated terminal has focus. */
  terminalFocus?: Maybe<Scalars['Boolean']>;
  /** A keybinding context key that is set when the integrated terminal has text selected. */
  terminalTextSelected?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget in integrated terminal is visible. */
  terminalFindWidgetVisible?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget find input in integrated terminal is focused. */
  terminalFindWidgetInputFocused?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget in integrated terminal is focused. */
  terminalFindWidgetFocused?: Maybe<Scalars['Boolean']>;
  /** Set when the find widget in a webview is visible */
  webviewFindWidgetVisible?: Maybe<Scalars['Boolean']>;
  taskRunning?: Maybe<Scalars['Boolean']>;
  referenceSearchTreeFocused?: Maybe<Scalars['Boolean']>;
  interactivePlaygroundFocus?: Maybe<Scalars['Boolean']>;
  outlineFiltered?: Maybe<Scalars['Boolean']>;
  outlineFocused?: Maybe<Scalars['Boolean']>;
  problemsViewFocus?: Maybe<Scalars['Boolean']>;
  problemFocus?: Maybe<Scalars['Boolean']>;
  problemsFilterFocus?: Maybe<Scalars['Boolean']>;
  relatedInformationFocus?: Maybe<Scalars['Boolean']>;
  inOutput?: Maybe<Scalars['Boolean']>;
  activeLogOutput?: Maybe<Scalars['Boolean']>;
  multiCursorModifier?: Maybe<Scalars['String']>;
  saveConflictResolutionContext?: Maybe<Scalars['Boolean']>;
  markersNavigationVisible?: Maybe<Scalars['Boolean']>;
  hasWordHighlights?: Maybe<Scalars['Boolean']>;
  profileSessionState?: Maybe<Scalars['String']>;
  extensionHostProfileRecorded?: Maybe<Scalars['Boolean']>;
  historyNavigationEnabled?: Maybe<Scalars['Boolean']>;
  historyNavigationWidget?: Maybe<Scalars['Boolean']>;
  nonEmptyWorkspace?: Maybe<Scalars['Boolean']>;
  defaultExtensionViews?: Maybe<Scalars['Boolean']>;
  searchMarketplaceExtensions?: Maybe<Scalars['Boolean']>;
  searchInstalledExtensions?: Maybe<Scalars['Boolean']>;
  searchOutdatedExtensions?: Maybe<Scalars['Boolean']>;
  searchEnabledExtensions?: Maybe<Scalars['Boolean']>;
  searchDisabledExtensions?: Maybe<Scalars['Boolean']>;
  hasInstalledExtensions?: Maybe<Scalars['Boolean']>;
  searchBuiltInExtensions?: Maybe<Scalars['Boolean']>;
  recommendedExtensions?: Maybe<Scalars['Boolean']>;
  defaultRecommendedExtensions?: Maybe<Scalars['Boolean']>;
  workspaceRecommendations?: Maybe<Scalars['Boolean']>;
  workspaceFolderRecommendations?: Maybe<Scalars['Boolean']>;
  addToWorkspaceRecommendations?: Maybe<Scalars['Boolean']>;
  addToWorkspaceFolderRecommendations?: Maybe<Scalars['Boolean']>;
};

export type IContextInput = {
  folder?: Maybe<Scalars['String']>;
  originalResourceScheme?: Maybe<IScmResourceGroups>;
  view?: Maybe<Scalars['String']>;
  viewItem?: Maybe<Scalars['String']>;
  gitOpenRepositoryCount?: Maybe<Scalars['Int']>;
  isInDiffEditor?: Maybe<Scalars['Boolean']>;
  isInDiffRightEditor?: Maybe<Scalars['Boolean']>;
  resourceScheme?: Maybe<Scalars['String']>;
  resourceFilename?: Maybe<Scalars['String']>;
  resourceLangId?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['URI']>;
  resourceExtName?: Maybe<Scalars['String']>;
  resourceSet?: Maybe<Scalars['Boolean']>;
  isFileSystemResource?: Maybe<Scalars['Boolean']>;
  inputFocus?: Maybe<Scalars['Boolean']>;
  suggestWidgetVisible?: Maybe<Scalars['Boolean']>;
  suggestWidgetMultipleSuggestions?: Maybe<Scalars['Boolean']>;
  suggestionMakesTextEdit?: Maybe<Scalars['Boolean']>;
  acceptSuggestionOnEnter?: Maybe<Scalars['Boolean']>;
  hasOtherSuggestions?: Maybe<Scalars['Boolean']>;
  groupFocusedInOpenEditors?: Maybe<Scalars['Boolean']>;
  dirtyEditor?: Maybe<Scalars['Boolean']>;
  resourceSelectedForCompare?: Maybe<Scalars['Boolean']>;
  fileCopied?: Maybe<Scalars['Boolean']>;
  breadcrumbsPossible?: Maybe<Scalars['Boolean']>;
  breadcrumbsVisible?: Maybe<Scalars['Boolean']>;
  breadcrumbsActive?: Maybe<Scalars['Boolean']>;
  canNavigateBack?: Maybe<Scalars['Boolean']>;
  canNavigateForward?: Maybe<Scalars['Boolean']>;
  canNavigateToLastEditLocation?: Maybe<Scalars['Boolean']>;
  dirtyDiffVisible?: Maybe<Scalars['Boolean']>;
  cancellableOperation?: Maybe<Scalars['Boolean']>;
  parameterHintsVisible?: Maybe<Scalars['Boolean']>;
  parameterHintsMultipleSignatures?: Maybe<Scalars['Boolean']>;
  markdownPreviewFocus?: Maybe<Scalars['Boolean']>;
  isMac?: Maybe<Scalars['Boolean']>;
  isLinux?: Maybe<Scalars['Boolean']>;
  isWindows?: Maybe<Scalars['Boolean']>;
  remoteAuthority?: Maybe<Scalars['String']>;
  remoteConnectionState?: Maybe<IProvidedRemoteConnectionStates>;
  hasMacNativeTabs?: Maybe<Scalars['Boolean']>;
  supportsWorkspaces?: Maybe<Scalars['Boolean']>;
  isDevelopment?: Maybe<Scalars['Boolean']>;
  workbenchState?: Maybe<Scalars['String']>;
  workspaceFolderCount?: Maybe<Scalars['Int']>;
  remoteFileDialogVisible?: Maybe<Scalars['Boolean']>;
  isFullscreen?: Maybe<Scalars['Boolean']>;
  atEndOfWord?: Maybe<Scalars['Boolean']>;
  scmRepository?: Maybe<Scalars['String']>;
  scmProvider?: Maybe<Scalars['String']>;
  scmResourceGroup?: Maybe<IScmResourceGroups>;
  inDiffEditorKey?: Maybe<Scalars['Boolean']>;
  isDominatedByLongLines?: Maybe<Scalars['Boolean']>;
  isWordWrapMinified?: Maybe<Scalars['Boolean']>;
  commentThread?: Maybe<Scalars['String']>;
  commentThreadisEmpty?: Maybe<Scalars['Boolean']>;
  commentIsEmpty?: Maybe<Scalars['Boolean']>;
  commentEditorFocused?: Maybe<Scalars['Boolean']>;
  interfaceOverviewVisible?: Maybe<Scalars['Boolean']>;
  inReferenceSearchEditor?: Maybe<Scalars['Boolean']>;
  referenceSearchVisible?: Maybe<Scalars['Boolean']>;
  listFocus?: Maybe<Scalars['Boolean']>;
  listSupportsMultiSelect?: Maybe<Scalars['Boolean']>;
  listHasSelectionOrFocus?: Maybe<Scalars['Boolean']>;
  listDoubleSelection?: Maybe<Scalars['Boolean']>;
  listMultiSelection?: Maybe<Scalars['Boolean']>;
  listSupportsKeyboardNavigation?: Maybe<Scalars['Boolean']>;
  WorkbenchListAutomaticKeyboardNavigationKey?: Maybe<Scalars['Boolean']>;
  accessibilityHelpWidgetVisible?: Maybe<Scalars['Boolean']>;
  inQuickOpenKey?: Maybe<Scalars['Boolean']>;
  supportedCodeAction?: Maybe<Scalars['String']>;
  renameInputVisible?: Maybe<Scalars['Boolean']>;
  hasSymbols?: Maybe<Scalars['Boolean']>;
  hasSnippetCompletions?: Maybe<Scalars['Boolean']>;
  messageVisible?: Maybe<Scalars['Boolean']>;
  editorHasCallHierarchyProvider?: Maybe<Scalars['Boolean']>;
  callHierarchyVisible?: Maybe<Scalars['Boolean']>;
  notificationCenterVisible?: Maybe<Scalars['Boolean']>;
  notificationToastsVisible?: Maybe<Scalars['Boolean']>;
  notificationFocus?: Maybe<Scalars['Boolean']>;
  searchViewletVisible?: Maybe<Scalars['Boolean']>;
  searchViewletFocus?: Maybe<Scalars['Boolean']>;
  inputBoxFocus?: Maybe<Scalars['Boolean']>;
  searchInputBoxFocus?: Maybe<Scalars['Boolean']>;
  replaceInputBoxFocus?: Maybe<Scalars['Boolean']>;
  patternIncludesInputBoxFocus?: Maybe<Scalars['Boolean']>;
  patternExcludesInputBoxFocus?: Maybe<Scalars['Boolean']>;
  replaceActive?: Maybe<Scalars['Boolean']>;
  hasSearchResult?: Maybe<Scalars['Boolean']>;
  firstMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchOrMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchOrFolderMatchFocus?: Maybe<Scalars['Boolean']>;
  fileMatchFocus?: Maybe<Scalars['Boolean']>;
  folderMatchFocus?: Maybe<Scalars['Boolean']>;
  matchFocus?: Maybe<Scalars['Boolean']>;
  inRecentFilesPicker?: Maybe<Scalars['Boolean']>;
  inWindowsPicker?: Maybe<Scalars['Boolean']>;
  findWidgetVisible?: Maybe<Scalars['Boolean']>;
  findInputFocussed?: Maybe<Scalars['Boolean']>;
  replaceInputFocussed?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the editor's text has focus (cursor is blinking). */
  editorTextFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the editor's text or an editor's widget has focus. */
  editorFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when any editor input has focus (regular editor, repl input...). */
  textInputFocus?: Maybe<Scalars['Boolean']>;
  editorReadonly?: Maybe<Scalars['Boolean']>;
  editorHasSelection?: Maybe<Scalars['Boolean']>;
  editorHasMultipleSelections?: Maybe<Scalars['Boolean']>;
  editorTabMoveFocus?: Maybe<Scalars['Boolean']>;
  isInEmbeddedEditor?: Maybe<Scalars['Boolean']>;
  canUndo?: Maybe<Scalars['Boolean']>;
  canRedo?: Maybe<Scalars['Boolean']>;
  editorLangId?: Maybe<Scalars['String']>;
  editorHasCompletionItemProvider?: Maybe<Scalars['Boolean']>;
  editorHasCodeActionsProvider?: Maybe<Scalars['Boolean']>;
  editorHasDefinitionProvider?: Maybe<Scalars['Boolean']>;
  editorHasDeclarationProvider?: Maybe<Scalars['Boolean']>;
  editorHasImplementationProvider?: Maybe<Scalars['Boolean']>;
  editorHasTypeDefinitionProvider?: Maybe<Scalars['Boolean']>;
  editorHasHoverProvider?: Maybe<Scalars['Boolean']>;
  editorHadDocumentHighlightProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentSymbolProvider?: Maybe<Scalars['Boolean']>;
  editorHasReferenceProvider?: Maybe<Scalars['Boolean']>;
  editorHasRenameProvider?: Maybe<Scalars['Boolean']>;
  editorHasSignatureHelpProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentFormattingProvider?: Maybe<Scalars['Boolean']>;
  editorHasDocumentSelectionFormattingProvider?: Maybe<Scalars['Boolean']>;
  editorHasMultipleDocumentSelectionFormattingProvider?: Maybe<Scalars['Boolean']>;
  activeEditor?: Maybe<Scalars['String']>;
  editorIsOpen?: Maybe<Scalars['Boolean']>;
  editorPinned?: Maybe<Scalars['Boolean']>;
  groupActiveEditorDirty?: Maybe<Scalars['Boolean']>;
  groupEditorsCount?: Maybe<Scalars['Int']>;
  textCompareEditorVisible?: Maybe<Scalars['Boolean']>;
  textCompareEditorActive?: Maybe<Scalars['Boolean']>;
  activeEditorGroupEmpty?: Maybe<Scalars['Boolean']>;
  multipleEditorGroups?: Maybe<Scalars['Boolean']>;
  inZenMode?: Maybe<Scalars['Boolean']>;
  inCenteredLayout?: Maybe<Scalars['Boolean']>;
  splitEditorsVertically?: Maybe<Scalars['Boolean']>;
  sideBarVisible?: Maybe<Scalars['Boolean']>;
  sideBarFocus?: Maybe<Scalars['Boolean']>;
  activeViewlet?: Maybe<Scalars['String']>;
  activePanel?: Maybe<Scalars['String']>;
  panelFocus?: Maybe<Scalars['Boolean']>;
  panelPosition?: Maybe<Scalars['String']>;
  debugType?: Maybe<Scalars['String']>;
  debugConfigurationType?: Maybe<Scalars['String']>;
  debugState?: Maybe<Scalars['String']>;
  inDebugMode?: Maybe<Scalars['Boolean']>;
  inDebugRepl?: Maybe<Scalars['Boolean']>;
  breakpointWidgetVisible?: Maybe<Scalars['Boolean']>;
  watchExpressionsFocused?: Maybe<Scalars['Boolean']>;
  variablesFocused?: Maybe<Scalars['Boolean']>;
  expressionSelected?: Maybe<Scalars['Boolean']>;
  breakpointSelected?: Maybe<Scalars['Boolean']>;
  callStackItemType?: Maybe<Scalars['Boolean']>;
  loadedScriptsSupported?: Maybe<Scalars['Boolean']>;
  loadedScriptsItemType?: Maybe<Scalars['Boolean']>;
  focusedSessionIsAttach?: Maybe<Scalars['Boolean']>;
  stepBackSupported?: Maybe<Scalars['Boolean']>;
  restartFrameSupported?: Maybe<Scalars['Boolean']>;
  inSettingsEditor?: Maybe<Scalars['Boolean']>;
  inSettingsJSONEditor?: Maybe<Scalars['Boolean']>;
  inSettingsSearch?: Maybe<Scalars['Boolean']>;
  settingsTocRowFocus?: Maybe<Scalars['Boolean']>;
  inKeybindings?: Maybe<Scalars['Boolean']>;
  inKeybindingsSearch?: Maybe<Scalars['Boolean']>;
  keybindingFocus?: Maybe<Scalars['Boolean']>;
  explorerViewletVisible?: Maybe<Scalars['Boolean']>;
  explorerResourceIsFolder?: Maybe<Scalars['Boolean']>;
  explorerResourceReadonly?: Maybe<Scalars['Boolean']>;
  explorerResourceIsRoot?: Maybe<Scalars['Boolean']>;
  explorerResourceCut?: Maybe<Scalars['Boolean']>;
  explorerResourceMoveableToTrash?: Maybe<Scalars['Boolean']>;
  filesExplorerFocus?: Maybe<Scalars['Boolean']>;
  openEditorsVisible?: Maybe<Scalars['Boolean']>;
  openEditorsFocus?: Maybe<Scalars['Boolean']>;
  explorerViewletFocus?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when there is at least one opened integrated terminal. */
  terminalIsOpen?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the integrated terminal has focus. */
  terminalFocus?: Maybe<Scalars['Boolean']>;
  /** A keybinding context key that is set when the integrated terminal has text selected. */
  terminalTextSelected?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget in integrated terminal is visible. */
  terminalFindWidgetVisible?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget find input in integrated terminal is focused. */
  terminalFindWidgetInputFocused?: Maybe<Scalars['Boolean']>;
  /** A context key that is set when the find widget in integrated terminal is focused. */
  terminalFindWidgetFocused?: Maybe<Scalars['Boolean']>;
  /** Set when the find widget in a webview is visible */
  webviewFindWidgetVisible?: Maybe<Scalars['Boolean']>;
  taskRunning?: Maybe<Scalars['Boolean']>;
  referenceSearchTreeFocused?: Maybe<Scalars['Boolean']>;
  interactivePlaygroundFocus?: Maybe<Scalars['Boolean']>;
  outlineFiltered?: Maybe<Scalars['Boolean']>;
  outlineFocused?: Maybe<Scalars['Boolean']>;
  problemsViewFocus?: Maybe<Scalars['Boolean']>;
  problemFocus?: Maybe<Scalars['Boolean']>;
  problemsFilterFocus?: Maybe<Scalars['Boolean']>;
  relatedInformationFocus?: Maybe<Scalars['Boolean']>;
  inOutput?: Maybe<Scalars['Boolean']>;
  activeLogOutput?: Maybe<Scalars['Boolean']>;
  multiCursorModifier?: Maybe<Scalars['String']>;
  saveConflictResolutionContext?: Maybe<Scalars['Boolean']>;
  markersNavigationVisible?: Maybe<Scalars['Boolean']>;
  hasWordHighlights?: Maybe<Scalars['Boolean']>;
  profileSessionState?: Maybe<Scalars['String']>;
  extensionHostProfileRecorded?: Maybe<Scalars['Boolean']>;
  historyNavigationEnabled?: Maybe<Scalars['Boolean']>;
  historyNavigationWidget?: Maybe<Scalars['Boolean']>;
  nonEmptyWorkspace?: Maybe<Scalars['Boolean']>;
  defaultExtensionViews?: Maybe<Scalars['Boolean']>;
  searchMarketplaceExtensions?: Maybe<Scalars['Boolean']>;
  searchInstalledExtensions?: Maybe<Scalars['Boolean']>;
  searchOutdatedExtensions?: Maybe<Scalars['Boolean']>;
  searchEnabledExtensions?: Maybe<Scalars['Boolean']>;
  searchDisabledExtensions?: Maybe<Scalars['Boolean']>;
  hasInstalledExtensions?: Maybe<Scalars['Boolean']>;
  searchBuiltInExtensions?: Maybe<Scalars['Boolean']>;
  recommendedExtensions?: Maybe<Scalars['Boolean']>;
  defaultRecommendedExtensions?: Maybe<Scalars['Boolean']>;
  workspaceRecommendations?: Maybe<Scalars['Boolean']>;
  workspaceFolderRecommendations?: Maybe<Scalars['Boolean']>;
  addToWorkspaceRecommendations?: Maybe<Scalars['Boolean']>;
  addToWorkspaceFolderRecommendations?: Maybe<Scalars['Boolean']>;
};

export type IContextMenu = {
  __typename?: 'ContextMenu';
  id?: Maybe<Scalars['String']>;
  isShow?: Maybe<Scalars['Boolean']>;
  anchor?: Maybe<IAnchor>;
  menuItems?: Maybe<Array<Maybe<IMenuItem>>>;
};

export type IContextMenuInput = {
  isShow?: Maybe<Scalars['Boolean']>;
  anchor?: Maybe<IAnchorInput>;
  menuItems?: Maybe<Array<Maybe<IMenuItemInput>>>;
};

/** @deprecated use IExtensionContributions */
export type IContributes = {
  __typename?: 'Contributes';
  menus?: Maybe<IMenus>;
  actions?: Maybe<Array<Maybe<IActions>>>;
};

export type ICopyEditorOptions_Input = {
  index?: Maybe<Scalars['Int']>;
  inactive?: Maybe<Scalars['Boolean']>;
  preserveFocus?: Maybe<Scalars['Boolean']>;
};

export type ICrashReporterStartOptions = {
  __typename?: 'CrashReporterStartOptions';
  companyName?: Maybe<Scalars['String']>;
  submitURL?: Maybe<Scalars['String']>;
  productName?: Maybe<Scalars['String']>;
  uploadToServer?: Maybe<Scalars['Boolean']>;
  ignoreSystemCrashHandler?: Maybe<Scalars['Boolean']>;
  extra?: Maybe<Scalars['AnyObject']>;
  crashesDirectory?: Maybe<Scalars['String']>;
};

export type ICreateFileOptions_Input = {
  /**
   * Overwrite the file to create if it already exists on disk. Otherwise
   * an error will be thrown (FILE_MODIFIED_SINCE).
   */
  overwrite?: Maybe<Scalars['Boolean']>;
};

export type ICursorState = {
  __typename?: 'CursorState';
  inSelectionMode?: Maybe<Scalars['Boolean']>;
  selectionStart?: Maybe<IPosition>;
  position?: Maybe<IPosition>;
};

export type ICursorState_Input = {
  inSelectionMode?: Maybe<Scalars['Boolean']>;
  selectionStart?: Maybe<IPositionInput>;
  position?: Maybe<IPositionInput>;
};

/**
 * An editor input to present data URIs in a binary editor. Data URIs have the form of:
 * data:[mime type];[meta data <key=value>;...];base64,[base64 encoded value]
 */
export type IDataUriEditorInput = IIEditorInput & IIEditorInputWithGroupFields & {
  __typename?: 'DataUriEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  /** The mime of the binary resource if known. */
  mime?: Maybe<Scalars['String']>;
  /** The etag of the binary resource if known. */
  etag?: Maybe<Scalars['String']>;
  /** The size of the binary resource if known. */
  size?: Maybe<Scalars['Int']>;
};



export type IDebugger = {
  __typename?: 'Debugger';
  label?: Maybe<Scalars['String']>;
  type?: Maybe<Scalars['String']>;
  runtime?: Maybe<Scalars['String']>;
};

export type IDefaultPreferencesResponse = {
  __typename?: 'DefaultPreferencesResponse';
  preferences?: Maybe<Array<Maybe<IPreferencesType>>>;
};

export type IDefaultSettings = IISettingsSubject & {
  __typename?: 'DefaultSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IDeleteFileOptions_Input = {
  useTrash?: Maybe<Scalars['Boolean']>;
  recursive?: Maybe<Scalars['Boolean']>;
};

export type IDetail = {
  __typename?: 'Detail';
  inputName?: Maybe<Scalars['String']>;
  inputType?: Maybe<IInputTypeDetail>;
  label?: Maybe<Scalars['String']>;
  placeholder?: Maybe<Scalars['String']>;
  defaultValue?: Maybe<Scalars['String']>;
  required?: Maybe<Scalars['Boolean']>;
};

export type IDetailInput = {
  inputName?: Maybe<Scalars['String']>;
  inputType?: Maybe<IInputTypeDetailInput>;
  label?: Maybe<Scalars['String']>;
  placeholder?: Maybe<Scalars['String']>;
  defaultValue?: Maybe<Scalars['String']>;
  required?: Maybe<Scalars['Boolean']>;
};

export type IDevToolsOptions = {
  __typename?: 'DevToolsOptions';
  mode?: Maybe<IDevToolsOptionsMode>;
};

export const enum IDevToolsOptionsMode {
  Right = 'right',
  Botton = 'botton',
  Undocked = 'undocked',
  Detach = 'detach'
};

export type IDialog = {
  __typename?: 'Dialog';
  dialogType?: Maybe<Scalars['String']>;
  detail?: Maybe<Array<Maybe<IDetail>>>;
  primaryButton?: Maybe<IPrimaryButtonAction>;
  secondaryButton?: Maybe<Scalars['String']>;
  checkbox?: Maybe<ICheckboxOptions>;
};

export type IDialogInput = {
  dialogType?: Maybe<Scalars['String']>;
  detail?: Maybe<Array<Maybe<IDetailInput>>>;
  primaryButton?: Maybe<IPrimaryButtonActionInput>;
  secondaryButton?: Maybe<Scalars['String']>;
  checkbox?: Maybe<ICheckboxOptionsInput>;
};

export type IDialogResult = {
  __typename?: 'DialogResult';
  confirmed?: Maybe<Scalars['Boolean']>;
  checkboxChecked?: Maybe<Scalars['Boolean']>;
};

/**
 * The base editor input for the diff editor. It is made up of two editor inputs, the original version
 * and the modified version.
 */
export type IDiffEditorInput = IIEditorInput & IIEditorInputWithGroupFields & {
  __typename?: 'DiffEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  originalInput?: Maybe<IEditorInput>;
  modifiedInput?: Maybe<IEditorInput>;
};

/**  A CDECode product documentation page. */
export type IDocSitePage = {
  __typename?: 'DocSitePage';
  /**  The title of this page. */
  title: Scalars['String'];
  /**  The content, as Markdown-rendered HTML. */
  contentHTML: Scalars['String'];
  /**  The page index, as rendered HTML. */
  indexHTML: Scalars['String'];
  /**  The filename of the file containing this page's content. */
  filePath: Scalars['String'];
};

/** @deprecated Not sure whether it is needed. */
export type IDockLayout = {
  __typename?: 'DockLayout';
  id?: Maybe<Scalars['Int']>;
  size?: Maybe<Scalars['Int']>;
  activeId?: Maybe<Scalars['String']>;
  mode?: Maybe<GroupOrientation>;
  children?: Maybe<Array<Maybe<IDockLayout>>>;
  tabs?: Maybe<Array<Maybe<IEditorInput>>>;
};

export type IDocumentFilter = {
  __typename?: 'DocumentFilter';
  language: Scalars['String'];
  schema?: Maybe<Scalars['String']>;
  pattern?: Maybe<Scalars['String']>;
};

export const enum IEditor_Id {
  TextResourceEditor = 'TEXT_RESOURCE_EDITOR',
  TextDiffEditor = 'TEXT_DIFF_EDITOR',
  BinaryDiffEditor = 'BINARY_DIFF_EDITOR',
  SideBySideEditor = 'SIDE_BY_SIDE_EDITOR'
};

export const enum IEditor_Input_Id {
  DataUriEditorInput = 'DATA_URI_EDITOR_INPUT',
  DefaultPreferencesEditorInput = 'DEFAULT_PREFERENCES_EDITOR_INPUT',
  DiffEditorInput = 'DIFF_EDITOR_INPUT',
  FileEditorInput = 'FILE_EDITOR_INPUT',
  KeybindingsEditorInput = 'KEYBINDINGS_EDITOR_INPUT',
  PreferencesEditorInput = 'PREFERENCES_EDITOR_INPUT',
  ResourceEditorInput = 'RESOURCE_EDITOR_INPUT',
  Settings2EditorInput = 'SETTINGS2_EDITOR_INPUT',
  SideBySideEditorInput = 'SIDE_BY_SIDE_EDITOR_INPUT',
  File = 'file'
};

export const enum IEditor_Input_Resource_Type_Id {
  /** If the resource is `file` */
  File = 'file'
};

export type IEditKeybindingItem = {
  __typename?: 'EditKeybindingItem';
  command?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  isDefault?: Maybe<Scalars['Boolean']>;
};

export const enum IEditorActionType {
  Init = 'init',
  Add = 'add',
  Remove = 'remove',
  RemoveAll = 'removeAll',
  ActivateEditor = 'activateEditor'
};

export const enum IEditorActivation {
  /**
   *    Activate the editor after it opened. This will automatically restore
   * the editor if it is minimized.
   */
  Activate = 'ACTIVATE',
  /**
   *    Only restore the editor if it is minimized but do not activate it.
   *
   * Note: will only work in combination with the `preserveFocus: true` option.
   * Otherwise, if focus moves into the editor, it will activate and restore
   * automatically.
   */
  Restore = 'RESTORE',
  /**
   *    Preserve the current active editor.
   *
   * Note: will only work in combination with the `preserveFocus: true` option.
   * Otherwise, if focus moves into the editor, it will activate and restore
   * automatically.
   */
  Preserve = 'PRESERVE'
};

export type IEditorChildren = IEditorPart | IEditorGroup;

export type IEditorChildren_Input = {
  /**
   * A unique identifier of this group that remains identical even if the
   * group is moved to different locations.
   */
  id: Scalars['Int'];
  mode?: Maybe<GroupOrientation>;
  children?: Maybe<Array<Maybe<IEditorChildren_Input>>>;
  /**
   * Size of the editor group.
   * Width when in `orientation.HORIZONTAL` and height when in `orientation.VERTICAL`
   */
  size?: Maybe<Scalars['Int']>;
  /** the id of current tab */
  activeId?: Maybe<Scalars['String']>;
  tabs?: Maybe<Array<Maybe<IEditorInput_Input>>>;
};

export type IEditorGroup = IIEditorGroup & {
  __typename?: 'EditorGroup';
  id: Scalars['Int'];
  label?: Maybe<Scalars['String']>;
  /** Whether it is an active group. */
  isActive?: Maybe<Scalars['Boolean']>;
  /**
   * Size of the editor group.
   * Width when in `orientation.HORIZONTAL` and height when in `orientation.VERTICAL`
   */
  size?: Maybe<Scalars['Int']>;
  /** the id of current tab */
  activeId?: Maybe<Scalars['String']>;
  /** All the Editors that are opened undered this group. */
  tabs?: Maybe<Array<Maybe<IEditorInput>>>;
};

export type IEditorGroupLayout = {
  __typename?: 'EditorGroupLayout';
  orientation?: Maybe<GroupOrientation>;
  groups?: Maybe<Array<Maybe<IGroupLayoutArgument>>>;
};

export type IEditorIdentifier = {
  __typename?: 'EditorIdentifier';
  groupId?: Maybe<Scalars['Int']>;
  editor?: Maybe<IEditorInput>;
};

export type IEditorInput = IDataUriEditorInput | IDiffEditorInput | IFileEditorInput | IKeybindingEditorInput | IPreferencesEditorInput | IResourceEditorInput | ISideBySideEditorInput | IUntitledEditorInput;

export type IEditorInput_Input = {
  id?: Maybe<Scalars['String']>;
  resource: Scalars['String'];
  name?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
};

export type IEditorLayout_Input = {
  /**
   * A unique identifier of this group that remains identical even if the
   * group is moved to different locations.
   */
  id: Scalars['Int'];
  mode?: Maybe<GroupOrientation>;
  /**
   * Size of the editor group.
   * Width when in `orientation.HORIZONTAL` and height when in `orientation.VERTICAL`
   */
  size?: Maybe<Scalars['Int']>;
  children?: Maybe<Array<Maybe<IEditorChildren_Input>>>;
};

export const enum IEditorOpenContext {
  /**
   * Default: the editor is opening via a programmatic call
   * to the editor service API.
   */
  Api = 'API',
  /**
   * Indicates that a user action triggered the opening, e.g,
   * via mouse or keyboard use.
   */
  User = 'USER'
};

export type IEditorOpenOptions_Input = {
  editorOpenPositioning?: Maybe<EditorOpenPositioning>;
  focusRecentEditorAfterClose?: Maybe<Scalars['Boolean']>;
  pinned?: Maybe<Scalars['Boolean']>;
  active?: Maybe<Scalars['Boolean']>;
  index?: Maybe<Scalars['Int']>;
};

export { EditorOpenPositioning };

export type IEditorOptions_Input = {
  /**
   * Tells the editor to not receive keyboard focus when the editor is being opened.
   *
   * Will also not activate the group the editor opens in unless the group is already
   * the active one. This behaviour can be overridden via the `activation` option.
   */
  preserveFocus?: Maybe<Scalars['Boolean']>;
  /**
   * This option is only relevant if an editor is opened into a group that is not active
   * already and allows to control if the inactive group should become active, restored
   * or preserved.
   *
   * By default, the editor group will become active unless `preserveFocus` or `inactive`
   * is specified.
   */
  activation?: Maybe<IEditorActivation>;
  /**
   * Tells the editor to reload the editor input in the editor even if it is identical to the one
   * already showing. By default, the editor will not reload the input if it is identical to the
   * one showing.
   */
  forceReload?: Maybe<Scalars['Boolean']>;
  /**
   * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
   *
   * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
   * to the side of another one or into a specific editor group.
   */
  revealIfVisible?: Maybe<Scalars['Boolean']>;
  /**
   * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
   *
   * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
   * to the side of another one or into a specific editor group.
   */
  revealIfOpened?: Maybe<Scalars['Boolean']>;
  /**
   * An editor that is pinned remains in the editor stack even when another editor is being opened.
   * An editor that is not pinned will always get replaced by another editor that is not pinned.
   */
  pinned?: Maybe<Scalars['Boolean']>;
  /**
   * An editor that is sticky moves to the beginning of the editors list within the group and will remain
   * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
   */
  sticky?: Maybe<Scalars['Boolean']>;
  /** The index in the document stack where to insert the editor into when opening. */
  index?: Maybe<Scalars['Int']>;
  /**
   * An active editor that is opened will show its contents directly. Set to true to open an editor
   * in the background.
   *
   * Will also not activate the group the editor opens in unless the group is already
   * the active one. This behaviour can be overridden via the `activation` option.
   */
  inactive?: Maybe<Scalars['Boolean']>;
  /**
   * Will not show an error in case opening the editor fails and thus allows to show a custom error
   * message as needed. By default, an error will be presented as notification if opening was not possible.
   */
  ignoreError?: Maybe<Scalars['Boolean']>;
  /**
   * Allows to override the editor that should be used to display the input:
   * - `undefined`: let the editor decide for itself
   * - `false`: disable overrides
   * - `string`: specific override by id
   */
  override?: Maybe<Scalars['AnyObject']>;
  /**
   * A optional hint to signal in which context the editor opens.
   *
   * If configured to be `EditorOpenContet.USER`, this hint can be
   * used in various places to control the experience. For example,
   * if the editor to open fails with an error, a notification could
   * inform about this in a modal dialog. If the editor opened through
   * some background task, the notification would show in the background,
   * not as a modal dialog.
   */
  context?: Maybe<IEditorOpenContext>;
};

/** Editor part is an extension with EditorGroup with Tabs */
export type IEditorPart = {
  __typename?: 'EditorPart';
  /**
   * A unique identifier of this group that remains identical even if the
   * group is moved to different locations.
   */
  id: Scalars['Int'];
  mode?: Maybe<GroupOrientation>;
  /** @deprecated use `size` */
  height?: Maybe<Scalars['Int']>;
  /**
   * Size of the editor group.
   * Width when in `orientation.HORIZONTAL` and height when in `orientation.VERTICAL`
   */
  size?: Maybe<Scalars['Int']>;
  children?: Maybe<Array<Maybe<IEditorChildren>>>;
};

export type IEditorPartConfiguration_Input = {
  /**
   * @description Controls whether opened editor should show in tabs or not.
   * @default true
   */
  showTabs?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether a top border is drawn on modified (dirty) editor tabs or not.
   * @default false
   */
  highlightModifiedTabs?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls the position of the editor's tabs close buttons, or disables them when set to 'off'.
   * @default 'right'
   */
  tabCloseButton?: Maybe<TabCloseButtonType>;
  /**
   * @description Controls the sizing of editor tabs.
   * @default 'fit'
   */
  tabSizing?: Maybe<TabSizingType>;
  /**
   * @description Controls whether tabs are closed in most recently used order or from left to right.
   * @default true
   */
  focusRecentEditorAfterClose?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether opened editors should show with an icon or not. This requires an icon theme to be enabled as well.
   * @default true
   */
  showIcons?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether opened editors show as preview. Preview editors are reused until they are pinned
   * (e.g. via double click or editing) and show up with an italic font style.
   * @default true
   */
  enablePreview?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether opened editors from Quick Open show as preview. Preview editors are reused until they are pinned
   * (e.g. via double click or editing)
   * @default true
   */
  enablePreviewFromQuickOpen?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether editors showing a file that was opened during the session should close automatically when getting
   * deleted or renamed by some other process. Disabling this will keep the editor open on such an event. Note that deleting from within
   * the application will always close the editor and that dirty files will never close to preserve your data.
   * @default false
   */
  closeOnFileDelete?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls where editors open. Select `left` or `right` to open editors to the left or right of the currently active one.
   * Select `first` or `last` to open editors independently from the currently active one.
   * @default 'right'
   */
  openPositioning?: Maybe<OpenPositioningType>;
  /**
   * @description Controls the default direction of editors that are opened side by side (e.g. from the explorer). By default,
   * editors will open on the right hand side of the currently active one. If changed to `down`, the editors will open belwo
   * the currently active one.
   * @default 'right'
   */
  openSideBySideDirection?: Maybe<OpenSideBySideDirection>;
  /**
   * @description Controls the behavior of empty editor groups when the last tab in the group is closed. When enabeld, empty groups
   * will automatically close. When disabled, empty groups will remain part of the grid.
   * @default true
   */
  closeEmptyGroup?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls whether an editor is revealed in any of the visible groups if opened. If disabled, an editor will prefer to
   * open in the currently active editor group. If enabled, an already opened editor will be revealed instead of opened again in the
   * currently active editor group. Note that there are some cases where this setting is ignored, e.g. when forcing an editor to open in a
   * specific group or to the side of the currently active group.
   * @default false
   */
  revealIfOpen?: Maybe<Scalars['Boolean']>;
  /**
   * @description: Navigate between open files using three-finger swipe horizontally.
   * @default: false
   */
  swipeToNavigate?: Maybe<Scalars['Boolean']>;
  /**
   * @description Controls the format of the label for an editor
   * @default: true
   */
  labelFormat?: Maybe<LableFormatType>;
  /**
   * @description Restores the last view state (e.g. scroll position) when re-opening files after they have been closed.
   * @default: true
   */
  restoreViewState?: Maybe<Scalars['Boolean']>;
};

/** Extends EditorPartConfiguration */
export type IEditorPartOptions_Input = {
  __typename?: 'EditorPartOptions_Input';
  showTabs?: Maybe<Scalars['Boolean']>;
  highlightModifiedTabs?: Maybe<Scalars['Boolean']>;
  tabCloseButton?: Maybe<TabCloseButtonType>;
  tabSizing?: Maybe<TabSizingType>;
  focusRecentEditorAfterClose?: Maybe<Scalars['Boolean']>;
  showIcons?: Maybe<Scalars['Boolean']>;
  enablePreview?: Maybe<Scalars['Boolean']>;
  enablePreviewFromQuickOpen?: Maybe<Scalars['Boolean']>;
  closeOnFileDelete?: Maybe<Scalars['Boolean']>;
  openPositioning?: Maybe<OpenPositioningType>;
  openSideBySideDirection?: Maybe<OpenSideBySideDirection>;
  closeEmptyGroup?: Maybe<Scalars['Boolean']>;
  revealIfOpen?: Maybe<Scalars['Boolean']>;
  swipeToNavigate?: Maybe<Scalars['Boolean']>;
  labelFormat?: Maybe<LableFormatType>;
  restoreViewState?: Maybe<Scalars['Boolean']>;
  iconTheme?: Maybe<Scalars['String']>;
};

export type IEditorSettings = {
  __typename?: 'EditorSettings';
  editorOpenPositioning?: Maybe<EditorOpenPositioning>;
  focusRecentEditorAfterClose?: Maybe<Scalars['Boolean']>;
};

export { EditorsOrder };

/** Represents a null return value. */
export type IEmptyResponse = {
  __typename?: 'EmptyResponse';
  alwaysNil?: Maybe<Scalars['String']>;
};

export type IEncodingStatus = IIStatusbarItem & {
  __typename?: 'EncodingStatus';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type IEndOfLineSequence = IIStatusbarItem & {
  __typename?: 'EndOfLineSequence';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type IEngines = {
  __typename?: 'Engines';
  node?: Maybe<Scalars['String']>;
  vscode?: Maybe<Scalars['String']>;
};

export type IEnterWorkspaceResult = {
  __typename?: 'EnterWorkspaceResult';
  workspace: IWorkspaceIdentifier;
  backupPath?: Maybe<Scalars['String']>;
};

export type IEnvironment = {
  __typename?: 'Environment';
  args?: Maybe<Scalars['AnyObject']>;
  execPath?: Maybe<Scalars['String']>;
  cliPath?: Maybe<Scalars['String']>;
  appRoot?: Maybe<Scalars['String']>;
  userHome?: Maybe<Scalars['String']>;
  userDataPath?: Maybe<Scalars['String']>;
  appNameLong?: Maybe<Scalars['String']>;
  appQuality?: Maybe<Scalars['String']>;
  appSettingsHome?: Maybe<Scalars['String']>;
  appSettingsPath?: Maybe<Scalars['String']>;
  appKeybindingsPath?: Maybe<Scalars['String']>;
  settingsSearchBuildId?: Maybe<Scalars['Int']>;
  settingsSearchUrl?: Maybe<Scalars['String']>;
  globalStorageHome?: Maybe<Scalars['String']>;
  workspaceStorageHome?: Maybe<Scalars['String']>;
  backupHome?: Maybe<Scalars['String']>;
  backupWorkspacesPath?: Maybe<Scalars['String']>;
  untitledWorkspacesHome?: Maybe<Scalars['URI']>;
  workspacesHome?: Maybe<Scalars['String']>;
  /** Specific to cdecode, workspaces project */
  workspacesProjectPath?: Maybe<Scalars['String']>;
  /** Specific to cdecode, workspace settings */
  workspaceSettingsPath?: Maybe<Scalars['String']>;
  isExtensionDevelopment?: Maybe<Scalars['Boolean']>;
  disableExtensions?: Maybe<Scalars['AnyObject']>;
  builtinExtensionsPath?: Maybe<Scalars['String']>;
  extensionsPath?: Maybe<Scalars['String']>;
  /**  This seems to be single URI as array was failing  */
  extensionDevelopmentLocationURI?: Maybe<Array<Maybe<Scalars['URI']>>>;
  extensionTestsPath?: Maybe<Scalars['String']>;
  debugExtensionHost?: Maybe<IExtensionHostDebugParams>;
  debugSearch?: Maybe<IIDebugParams>;
  logExtensionHostCommunication?: Maybe<Scalars['Boolean']>;
  isBuilt?: Maybe<Scalars['Boolean']>;
  wait?: Maybe<Scalars['Boolean']>;
  status?: Maybe<Scalars['Boolean']>;
  performance?: Maybe<Scalars['Boolean']>;
  log?: Maybe<Scalars['String']>;
  logsPath?: Maybe<Scalars['String']>;
  verbose?: Maybe<Scalars['Boolean']>;
  logLevel?: Maybe<Scalars['String']>;
  skipGettingStarted?: Maybe<Scalars['Boolean']>;
  skipReleaseNotes?: Maybe<Scalars['Boolean']>;
  skipAddToRecentlyOpened?: Maybe<Scalars['Boolean']>;
  nodeCachedDataDir?: Maybe<Scalars['String']>;
  installSourcePath?: Maybe<Scalars['String']>;
  disableUpdates?: Maybe<Scalars['Boolean']>;
  disableCrashReporter?: Maybe<Scalars['Boolean']>;
  driverHandle?: Maybe<Scalars['String']>;
  driverVerbose?: Maybe<Scalars['Boolean']>;
  keyboardLayoutResource?: Maybe<Scalars['URI']>;
  keybindingsResource?: Maybe<Scalars['URI']>;
  userRoamingDataHome?: Maybe<Scalars['URI']>;
  settingsResource?: Maybe<Scalars['URI']>;
};

export const enum IEnvironmentServiceAction {
  Environment = 'environment'
};

export type IExtensionColor = {
  __typename?: 'ExtensionColor';
  id?: Maybe<Scalars['ID']>;
  description?: Maybe<Scalars['String']>;
  defaults?: Maybe<IExtensionColorTypes>;
};

export type IExtensionColorTypes = {
  __typename?: 'ExtensionColorTypes';
  light?: Maybe<Scalars['String']>;
  dark?: Maybe<Scalars['String']>;
  highContrast?: Maybe<Scalars['String']>;
};

export type IExtensionConfiguration = {
  __typename?: 'ExtensionConfiguration';
  properties?: Maybe<Scalars['JSON']>;
};

export type IExtensionConfigurationProperty = {
  __typename?: 'ExtensionConfigurationProperty';
  description?: Maybe<Scalars['String']>;
  type?: Maybe<Array<Maybe<Scalars['String']>>>;
  defaults?: Maybe<Scalars['JSON']>;
};

export type IExtensionContributions = {
  __typename?: 'ExtensionContributions';
  /** @deprecated use commands */
  actions?: Maybe<Array<Maybe<IActions>>>;
  /**
   * @title contributes.commands
   * @description Contribute the UI for a command consisting of a title and (optionally) an icon, category,
   * and enabled state. Enablement is expressed with `when` clauses. By default, commands show in the
   * Command Pallette but they can also show in other menus.
   *
   * Presentation of contributed commands depends on the containing menu. The Command Pallette, for instance, prefixes
   * commands with their `category`, allowing for easy grouping. However, the Command Pallette doesn't show icons nor disabled
   * commands. The editor context menu, on the other hand, show disabled items but doesn't show the category label.
   *
   * Note: When a command is invoked (from a key binding, from the Command Palette, any other menu, or programmatically), VS Code will emit an activationEvent onCommand:${command}.
   *
   * @example
   * ```
   *    "contributes": {
   *        "commands": [{
   *            "command": "extension.sayHello",
   *            "title": "Hello World",
   *            "category": "Hello"
   *        }]
   *    }
   * ```
   */
  commands?: Maybe<Array<Maybe<IActions>>>;
  /**
   * @title contributes.configuration
   * @description Contribute configuration keys that will be exposed to the user. The user will be able to set these configuration options either from User Settings or from the Workspace Settings.
   * When contributing configuration keys, a JSON schema describing these keys is actually contributed. This ensures the user gets great tooling support when authoring VS Code settings files.
   * You can read these values from your extension using vscode.workspace.getConfiguration('myExtension').
   *
   * Note: If you use markdownDescription instead of description, your setting description will be rendered as Markdown in the settings UI.
   *
   * @example
   * ```
   * "contributes": {
   *     "configuration": {
   *         "type": "object",
   *         "title": "TypeScript configuration",
   *         "properties": {
   *             "typescript.useCodeSnippetsOnMethodSuggest": {
   *                 "type": "boolean",
   *                 "default": false,
   *                 "description": "Complete functions with their parameter signature."
   *             },
   *             "typescript.tsdk": {
   *                 "type": ["string", "null"],
   *                 "default": null,
   *                 "description": "Specifies the folder path containing the tsserver and lib*.d.ts files to use."
   *             }
   *         }
   *     }
   * }
   * ```
   */
  configuration?: Maybe<Array<Maybe<IExtensionConfiguration>>>;
  debuggers?: Maybe<Array<Maybe<IDebugger>>>;
  /**
   *      @title contributes.grammars
   *      @description Contribute a TextMate grammar to a language. You must provide the language this grammar applies to, the TextMate scopeName for the grammar and the file path.
   *
   *      Note: The file containing the grammar can be in JSON (filenames ending in .json) or in XML plist format (all other files).
   *
   *      @example
   *         ```json
   *         "contributes": {
   *             "grammars": [{
   *                 "language": "markdown",
   *                 "scopeName": "text.html.markdown",
   *                 "path": "./syntaxes/markdown.tmLanguage.json",
   *                 "embeddedLanguages": {
   *                     "meta.embedded.block.frontmatter": "yaml",
   *                     ...
   *                 }
   *             }]
   *         }
   * ```
   */
  grammars?: Maybe<Array<Maybe<IGrammar>>>;
  /**
   * @title contributes.jsonValidation
   * @description Contribute a validation schema for a specific type of json file. The url value can be either a local path to a schema file included in the extension or a remote server URL such as a json schema store.
   *
   * @example
   *    "contributes": {
   *        "jsonValidation": [{
   *            "fileMatch": ".jshintrc",
   *            "url": "http://json.schemastore.org/jshintrc"
   *        }]
   *    }
   */
  jsonValidation?: Maybe<Array<Maybe<IExtensionJsonValidation>>>;
  /**
   * @title contributes.keybindings
   * @description Contribute a key binding rule defining what command should be invoked when the user presses a key combination. See the Key Bindings topic where key bindings are explained in detail.
   *
   * Contributing a key binding will cause the Default Keyboard Shortcuts to display your rule, and every UI representation of the command will now show the key binding you have added. And, of course, when the user presses the key combination the command will be invoked.
   *
   * Note: Because VS Code runs on Windows, macOS and Linux, where modifiers differ, you can use "key" to set the default key combination and overwrite it with a specific platform.
   *
   * Note: When a command is invoked (from a key binding or from the Command Palette), VS Code will emit an activationEvent onCommand:${command}.
   *
   * @example
   * Defining that Ctrl+F1 under Windows and Linux and Cmd+F1 under macOS trigger the "extension.sayHello" command:
   *
   * ```json
   * "contributes": {
   *     "keybindings": [{
   *         "command": "extension.sayHello",
   *         "key": "ctrl+f1",
   *         "mac": "cmd+f1",
   *         "when": "editorTextFocus"
   *     }]
   * }
   * ```
   */
  keybindings?: Maybe<Array<Maybe<IKeyBinding>>>;
  /**
   * @title contributes.languages
   * @description Contribute definition of a language. This will introduce a new language or enrich the knowledge VS Code has about a language.
   *
   * The main effects of contributes.languages are:
   *
   * Define a languageId that can be reused in other parts of VS Code API, such as vscode.TextDocument.getLanguageId() and the onLanguage Activation Events.
   * You can contribute a human-readable using the aliases field. The first item in the list will be used as the human-readable label.
   * Associate file name extensions, file name patterns, files that begin with a specific line (such as hashbang), mimetypes to that languageId.
   * Contribute a set of Declarative Language Features for the contributed language. Learn more about the configurable editing features in the Language Configuration Guide.
   *
   * @example
   * ```
   *    "contributes": {
   *        "languages": [{
   *            "id": "python",
   *            "extensions": [ ".py" ],
   *            "aliases": [ "Python", "py" ],
   *            "filenames": [ ... ],
   *            "firstLine": "^#!/.*\\bpython[0-9.-]*\\b",
   *            "configuration": "./language-configuration.json"
   *        }]
   *    }
   * ```
   */
  languages?: Maybe<Array<Maybe<IExtensionLanguage>>>;
  /**
   * @title contributes.menus
   * @description Contribute a menu item for a command to the editor or Explorer. The menu item definition contains the command that should be invoked when selected and the condition under which the item should show. The latter is defined with the when clause, which uses the key bindings when clause contexts.
   *
   * In addition to the mandatory command property, an alternative command can be defined using the alt-property. It will be shown and invoked when pressing Alt while opening a menu.
   *
   * Last, a group property defines sorting and grouping of menu items. The navigation group is special as it will always be sorted to the top/beginning of a menu.
   *
   * Note that when clauses apply to menus and enablement clauses to commands. The enablement applies to all menus and even keybindings while the when only applies to a single menu.
   *
   * Currently extension writers can contribute to:
   *
   * The global Command Palette - commandPalette
   * The Explorer context menu - explorer/context
   * The editor context menu - editor/context
   * The editor title menu bar - editor/title
   * The editor title context menu - editor/title/context
   * The debug callstack view context menu - debug/callstack/context
   * The debug toolbar - debug/toolbar
   * The SCM title menu - scm/title
   * SCM resource groups menus - scm/resourceGroup/context
   * SCM resources menus - scm/resource/context
   * SCM change title menus - scm/change/title
   * The View title menu - view/title
   * The View item menu - view/item/context
   * The macOS Touch Bar - touchBar
   * The comment thread title - comments/commentThread/title
   * The comment thread actions - comments/commentThread/context
   * The comment title - comments/comment/title
   * The comment actions - comments/comment/context
   * Note: When a command is invoked from a (context) menu, VS Code tries to infer the currently selected resource and passes that as a parameter when invoking the command. For instance, a menu item inside the Explorer is passed the URI of the selected resource and a menu item inside an editor is passed the URI of the document.
   *
   * In addition to a title, commands can also define icons which VS Code will show in the editor title menu bar.
   *
   * @example
   * "contributes": {
   *     "menus": {
   *         "editor/title": [{
   *             "when": "resourceLangId == markdown",
   *             "command": "markdown.showPreview",
   *             "alt": "markdown.showPreviewToSide",
   *             "group": "navigation"
   *         }]
   *     }
   * }
   */
  menus?: Maybe<IMenus>;
  /**
   * @title contributes.snippets
   * @description Contribute snippets for a specific language. The language attribute is the language identifier and the path is the relative path to the snippet file, which defines snippets in the VS Code snippet format.
   *
   * @example
   *
   * ```json
   * "contributes": {
   *     "snippets": [{
   *         "language": "go",
   *         "path": "./snippets/go.json"
   *     }]
   * }
   * ```
   */
  snippets?: Maybe<Array<Maybe<ISnippet>>>;
  /**
   * @title contributes.themes
   * @description Contribute a TextMate theme to VS Code. You must specify a label, whether the theme is a dark theme or a light theme (such that the rest of VS Code changes to match your theme) and the path to the file (XML plist format).
   *
   * @example
   *    ```json
   *    "contributes": {
   *        "themes": [{
   *            "label": "Monokai",
   *            "uiTheme": "vs-dark",
   *            "path": "./themes/Monokai.tmTheme"
   *        }]
   *    }
   *    ```
   */
  themes?: Maybe<Array<Maybe<IThemeLabel>>>;
  iconThemes?: Maybe<Array<Maybe<IThemeLabel>>>;
  /**
   *  @title contributes.viewsContainers
   *  @description Contribute a view container into which Custom views can be contributed. You must specify an identifier, title, and an icon for the view container. At present, you can contribute them to the Activity Bar (activitybar) only. Below example shows how the Package Explorer view container is contributed to the Activity Bar and how views are contributed to it.
   *
   *  @example
   *     ```json
   *     "contributes": {
   *             "viewsContainers": {
   *                 "activitybar": [
   *                     {
   *                         "id": "package-explorer",
   *                         "title": "Package Explorer",
   *                         "icon": "resources/package-explorer.svg"
   *                     }
   *                 ]
   *             },
   *             "views": {
   *                 "package-explorer": [
   *                     {
   *                         "id": "package-dependencies",
   *                         "name": "Dependencies"
   *                     },
   *                     {
   *                         "id": "package-outline",
   *                         "name": "Outline"
   *                     }
   *                 ]
   *             }
   *     }
   * ```
   */
  viewsContainers?: Maybe<Scalars['JSON']>;
  /**
   * @title contributes.viewsContainers
   * @description Contribute a view container into which Custom views can be contributed. You must specify an identifier, title, and an icon for the view container. At present, you can contribute them to the Activity Bar (activitybar) only. Below example shows how the Package Explorer view container is contributed to the Activity Bar and how views are contributed to it.
   *
   * @example
   * ```json
   *    "contributes": {
   *            "viewsContainers": {
   *                "activitybar": [
   *                    {
   *                        "id": "package-explorer",
   *                        "title": "Package Explorer",
   *                        "icon": "resources/package-explorer.svg"
   *                    }
   *                ]
   *            },
   *            "views": {
   *                "package-explorer": [
   *                    {
   *                        "id": "package-dependencies",
   *                        "name": "Dependencies"
   *                    },
   *                    {
   *                        "id": "package-outline",
   *                        "name": "Outline"
   *                    }
   *                ]
   *            }
   *    }
   * ```
   */
  views?: Maybe<Scalars['JSON']>;
  /**
   * @title contributes.colors
   * @description Contributes new themable colors. These colors can be used by the extension in editor decorators and in the status bar. Once defined, users can customize the color in the workspace.colorCustomization setting and user themes can set the color value.
   *
   * @example
   * ```json
   *    "contributes": {
   *      "colors": [{
   *          "id": "superstatus.error",
   *          "description": "Color for error message in the status bar.",
   *          "defaults": {
   *              "dark": "errorForeground",
   *              "light": "errorForeground",
   *              "highContrast": "#010203"
   *          }
   *      }]
   *    }
   * ```
   * Color default values can be defined for light, dark and high contrast theme and can either be a reference to an existing color or a Color Hex Value.
   */
  colors?: Maybe<Array<Maybe<IExtensionColor>>>;
  localizations?: Maybe<Array<Maybe<ILocalization>>>;
};

export type IExtensionHostDebugParams = IIDebugParams & {
  __typename?: 'ExtensionHostDebugParams';
  port?: Maybe<Scalars['Int']>;
  break?: Maybe<Scalars['Boolean']>;
  debugId?: Maybe<Scalars['String']>;
};

/**
 * **!Do not construct directly!**
 * **!Only static methods because it gets serialized!**
 *
 * This represents the "canonical" version for an extension identifier. Exntension ids
 * have to be case-insensitive (due to the marketplace), but we must ensure case
 * preservation because the extension API is already public at this time.
 *
 * For example, given an extension with the publisher `"Hello` and the name `"World"`,
 * its canonical extension identifier is `"Hello.World"`. This extension could be
 * referenced in some other extension's dependencies using the string `"hello.world"`.
 *
 * To make matter more complicated, an extension can optionally have an UUID. When two
 * extensions have the same UUID, they are considered equal even if their identifier is different.
 */
export type IExtensionIdentifier = {
  __typename?: 'ExtensionIdentifier';
  id?: Maybe<Scalars['String']>;
  uuid?: Maybe<Scalars['String']>;
};

export type IExtensionInstance = {
  __typename?: 'ExtensionInstance';
  pid?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  path?: Maybe<Scalars['String']>;
  env?: Maybe<Array<Maybe<Scalars['String']>>>;
  status?: Maybe<Scalars['String']>;
  extensionID?: Maybe<Scalars['ID']>;
  monit?: Maybe<IProcessMonitoring>;
};

export type IExtensionJsonValidation = {
  __typename?: 'ExtensionJSONValidation';
  fileMatch?: Maybe<Scalars['String']>;
  url?: Maybe<Scalars['String']>;
};

export const enum IExtensionKind {
  Ui = 'ui',
  Workspace = 'workspace'
};

export type IExtensionLanguage = {
  __typename?: 'ExtensionLanguage';
  id?: Maybe<Scalars['ID']>;
  extensions?: Maybe<Array<Maybe<Scalars['String']>>>;
  aliases?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IExtensionManifest = {
  __typename?: 'ExtensionManifest';
  /**  The name of the extension - should be all lowercase with no spaces  */
  name?: Maybe<Scalars['String']>;
  /**  SemVer compatible version.  */
  version?: Maybe<Scalars['String']>;
  /**  The entry point to your extension  */
  main?: Maybe<Scalars['String']>;
  /**  Array of approved badges to display in the sidebar of the Marketplace's extension page. Each badge is an object containing 3 properties: url for the badge's image URL, href for the link users will follow when clicking the badge and description.  */
  badges?: Maybe<Array<Maybe<Scalars['String']>>>;
  /**  Sets the extension to be flagged as a Preview in the Marketplace.  */
  preview?: Maybe<Scalars['Boolean']>;
  /**  An array of keywords to make it easier to find the extension. These are included with other extension Tags on the Marketplace. This list is currently limited to 5 keywords.  */
  keywords?: Maybe<Array<Maybe<Scalars['String']>>>;
  /**
   *  Refer to npm's documentation. If you do have a LICENSE file in the root of
   * your extension, the value for license should be "SEE LICENSE IN <filename>".
   */
  license?: Maybe<Scalars['String']>;
  homepage?: Maybe<Scalars['String']>;
  /**  The publisher name  */
  publisher?: Maybe<Scalars['String']>;
  /**  the categories you want to use for the extensions allowed values: [Programming Languages, Snippets, Linters, Themes, Debuggers, Formatters, Keymaps, SCM Providers, Other, Extension Packs, Language Packs]  */
  categories?: Maybe<Scalars['String']>;
  /**  A short description of what your extension is and does.  */
  description?: Maybe<Scalars['String']>;
  extensionID?: Maybe<Scalars['String']>;
  /**  The display name for the extension used in the Marketplace.  */
  displayName?: Maybe<Scalars['String']>;
  /**  Any runtime Node.js dependencies your extensions needs. Exactly the same as npm's dependencies.  */
  dependencies?: Maybe<Scalars['JSON']>;
  /** Any development Node.js dependencies your extension needs. Exactly the same as npm's devDependencies.  */
  devDependencies?: Maybe<Scalars['JSON']>;
  /**
   * An array with the ids of extensions bundled with this extension. These other extensions will be installed when the primary extension is installed. The id of an extension is always
   * `${publisher}.${name}`. For example: vscode.csharp.
   */
  extensionPack?: Maybe<Array<Maybe<Scalars['String']>>>;
  /** An extension can be of 'ui' | 'workspace' */
  extensionKind?: Maybe<IExtensionKind>;
  /**
   * An array with the ids of extensions that this extension depends on. These other extensions will be installed when the primary extension is installed. The id of an extension is always
   * `${publisher}.${name}`. For example: vscode.csharp.
   */
  extensionDependencies?: Maybe<Array<Maybe<Scalars['String']>>>;
  bundle?: Maybe<Scalars['String']>;
  raw?: Maybe<Scalars['String']>;
  assets?: Maybe<Array<Maybe<IAssets>>>;
  /**  Exactly the same as npm's scripts but with extra VS Code specific fields such as vscode:prepublish or vscode:uninstall.  */
  scripts?: Maybe<IScripts>;
  bundles?: Maybe<IBundles>;
  bundleURL?: Maybe<Scalars['String']>;
  extension?: Maybe<IExtensionPackageType>;
  /**
   *  An object containing at least the vscode key matching
   * the versions of VS Code that the extension
   * is compatible with. Cannot be *.
   * For example: ^0.10.5 indicates compatibility with a minimum VS Code version of 0.10.5.
   */
  engines?: Maybe<IEngines>;
  /**  Controls the Markdown rendering engine used in the Marketplace. Either github (default) or standard.  */
  makrdown?: Maybe<Scalars['String']>;
  /**  Controls the Q & A link in the Marketplace. Set to marketplace to enable the default Marketplace Q & A site. Set to a string to provide the URL of a custom Q & A site. Set to false to disable Q & A altogether.  */
  qna?: Maybe<Scalars['String']>;
  author?: Maybe<IAuthor>;
  /**  Helps format the Marketplace header to match your icon. See details below.  */
  galleryBanner?: Maybe<IGalleryBanner>;
  /**  An array of the activation events for this extension.  */
  activationEvents?: Maybe<Array<Maybe<Scalars['String']>>>;
  /**  An object describing the extension's contributions.  */
  contributes?: Maybe<IExtensionContributions>;
  /**  The path to the icon of at least 128x128 pixels (256x256 for Retina screens).  */
  icon?: Maybe<Scalars['String']>;
  /**
   * @description Any development Node.js bugs reporting location of your extension.
   * @example
   *    "bugs": {
   *        "url": "https://github.com/Microsoft/vscode-wordcount/issues",
   *        "email": "smcbreen@microsoft.com"
   *    },
   */
  bugs?: Maybe<IExtensionManifestBugs>;
  /**
   * Any development Node.js repository location of your extension.
   * @example
   *   "repository": {
   *        "type": "git",
   *        "url": "https://github.com/Microsoft/vscode-wordcount.git"
   *    }
   */
  repository?: Maybe<IExtensionManifestRepository>;
  /** To enable proposed Api's */
  enableProposedApi?: Maybe<Scalars['Boolean']>;
  /** Add support for api:none */
  api?: Maybe<Scalars['String']>;
};

export type IExtensionManifestBugs = {
  __typename?: 'ExtensionManifestBugs';
  url?: Maybe<Scalars['String']>;
  email?: Maybe<Scalars['String']>;
};

export type IExtensionManifestRepository = {
  __typename?: 'ExtensionManifestRepository';
  type?: Maybe<Scalars['String']>;
  url?: Maybe<Scalars['String']>;
};

export type IExtensionPackageType = {
  __typename?: 'ExtensionPackageType';
  type?: Maybe<Scalars['String']>;
};

export type IExtensionRegistry = {
  __typename?: 'ExtensionRegistry';
  /**  To find an extension by its GraphQL ID, use Query.node  */
  extension?: Maybe<IRegistryExtension>;
  /**
   * Find an extension by its extension ID (which is the concatenation of the publisher naem, a slash ("/"), and the extension name).
   *
   * To find an extension by its GraphQL ID, use Query.node
   * extension(extensionID: String!): RegistryExtension
   * A list of extensions published in the extension registry.
   */
  extensions: IRegistryExtensionConnection;
  /**  List of extension releases  */
  releases?: Maybe<Array<Maybe<IExtensionRelease>>>;
  /**  A list of publishers with at least 1 extension in the registry.  */
  publishers: IRegistryPublisherConnection;
  /**  A list of publishers that the viewer may publish extensions as.  */
  viewerPublishers: Array<IRegistryPublisher>;
  /**
   * The extension ID prefix for extensions that are published in the local extension registry. This is the
   * hostname ( and port, if non-default HTTP/HTTPS) of the CDEBase "appURL" site configuration property.
   *
   * It is null if extensions published on this CDEBase site do not have an extension ID prefix.
   *
   * Examples: "cdebase.example.com/", "cdebase.example.com:1234/"
   */
  localExtensionIDPrefix?: Maybe<Scalars['String']>;
};


export type IExtensionRegistryExtensionArgs = {
  extensionID: Scalars['String'];
};


export type IExtensionRegistryExtensionsArgs = {
  first?: Maybe<Scalars['Int']>;
  publisher?: Maybe<Scalars['ID']>;
  query?: Maybe<Scalars['String']>;
  local?: Maybe<Scalars['Boolean']>;
  remote?: Maybe<Scalars['Boolean']>;
  prioritizeExtensionIDs?: Maybe<Array<Scalars['String']>>;
  includeWIP?: Maybe<Scalars['Boolean']>;
};


export type IExtensionRegistryReleasesArgs = {
  extensionID: Scalars['String'];
};


export type IExtensionRegistryPublishersArgs = {
  first?: Maybe<Scalars['Int']>;
};

/**  The result of Mutation.extensionRegistry.createExtension. */
export type IExtensionRegistryCreateExtensionResult = {
  __typename?: 'ExtensionRegistryCreateExtensionResult';
  /**  The newly created extension. */
  extension: IRegistryExtension;
};

/**  The result of Mutation.extensionRegistry.publishExtension. */
export type IExtensionRegistryPublishExtensionResult = {
  __typename?: 'ExtensionRegistryPublishExtensionResult';
  /**  The extension that was just published. */
  extension: IRegistryExtension;
};

/**  The result of Mutation.extensionRegistry.updateExtension. */
export type IExtensionRegistryUpdateExtensionResult = {
  __typename?: 'ExtensionRegistryUpdateExtensionResult';
  /**  The newly updated extension. */
  extension: IRegistryExtension;
};

export type IExtensionRelease = {
  __typename?: 'ExtensionRelease';
  id?: Maybe<Scalars['ID']>;
  bundle?: Maybe<Scalars['String']>;
  bundleURL?: Maybe<Scalars['String']>;
  version?: Maybe<Scalars['String']>;
  manifest: Scalars['String'];
  sourceMap?: Maybe<Scalars['String']>;
  extensionID?: Maybe<Scalars['String']>;
  creatorUserId?: Maybe<Scalars['String']>;
  releaseVersion?: Maybe<Scalars['String']>;
  activationEvents?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export const enum IExtensionType {
  System = 'System',
  User = 'User'
};

export type IFieldError = {
  __typename?: 'FieldError';
  field: Scalars['String'];
  message: Scalars['String'];
};

export type IFileChange = {
  __typename?: 'FileChange';
  /** The type of change that occurred to the file */
  type?: Maybe<IFileChangeType>;
  /** The unified resource identifier of the file that changed. */
  resource?: Maybe<Scalars['URI']>;
};

/** Possible changes that can occur to a file. */
export const enum IFileChangeType {
  Updated = 'UPDATED',
  Added = 'ADDED',
  Deleted = 'DELETED'
};

export type IFileContent = IIBaseStatWithMetadata & IIBaseStat & {
  __typename?: 'FileContent';
  resource: Scalars['URI'];
  name: Scalars['String'];
  mtime: Scalars['BigInt'];
  etag: Scalars['String'];
  size: Scalars['Int'];
  isReadonly?: Maybe<Scalars['Boolean']>;
  /**  The content of a file as buffer.  */
  value?: Maybe<Scalars['VSBuffer']>;
};

export const enum IFileContentStatus {
  Pending = 'PENDING',
  Start = 'START',
  InProgress = 'IN_PROGRESS',
  End = 'END',
  Error = 'ERROR',
  Restore = 'RESTORE'
};

export type IFileDeleteOptions = {
  __typename?: 'FileDeleteOptions';
  recursive: Scalars['Boolean'];
  useTrash: Scalars['Boolean'];
};

export type IFileEditorInput = IIFileEditorInput & IIEditorInput & IIEditorInputWithGroupFields & IIEncodingSupport & IIModeSupport & {
  __typename?: 'FileEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  preferredEncoding?: Maybe<Scalars['String']>;
  preferredMode?: Maybe<Scalars['String']>;
  forceOpenAsBinary?: Maybe<Scalars['Boolean']>;
  encoding?: Maybe<Scalars['String']>;
  mode?: Maybe<Scalars['String']>;
};

export type IFileFilter = {
  __typename?: 'FileFilter';
  extensions?: Maybe<Array<Maybe<Scalars['String']>>>;
  name?: Maybe<Scalars['String']>;
};

export type IFileIndexProviderStats = {
  __typename?: 'FileIndexProviderStats';
  providerTime: Scalars['Int'];
  providerResultCount: Scalars['Int'];
  fileWalkTime: Scalars['Int'];
  directoriesWalked: Scalars['Int'];
  filesWalked: Scalars['Int'];
};

export const enum IFileLoadReason {
  Editor = 'EDITOR',
  Reference = 'REFERENCE',
  Other = 'OTHER'
};

export type IFileMatch = IIFileMatch & {
  __typename?: 'FileMatch';
  resource?: Maybe<Scalars['URI']>;
  results?: Maybe<Array<Maybe<ITextSearchResult>>>;
};

/** same as ModelState as in vscode */
export const enum IFileModelState {
  /**  A model is saved.  */
  Saved = 'SAVED',
  /**  A model is dirty.  */
  Dirty = 'DIRTY',
  /**  A model is transitioning from dirty to saved.  */
  PendingSave = 'PENDING_SAVE',
  /**
   * A model is in conflict mode when changes cannot be saved because the
   * underlying file has changed. Models in conflict mode are always dirty.
   */
  Conflict = 'CONFLICT',
  /**  A model is in orphan state when the underlying file has been deleted.  */
  Orphan = 'ORPHAN',
  /**
   * Any error that happens during a save that is not causing the CONFLICT state.
   * Models in error mode are always dirty.
   */
  Error = 'ERROR',
  /**  Loading  */
  PendingLoad = 'PENDING_LOAD',
  /**  Unkown  */
  Unknown = 'UNKNOWN'
};

export type IFileOpenOptions = {
  __typename?: 'FileOpenOptions';
  create: Scalars['Boolean'];
};

export const enum IFileOperation {
  Create = 'CREATE',
  Delete = 'DELETE',
  Move = 'MOVE',
  Copy = 'COPY'
};

export type IFileOperationOutput = {
  __typename?: 'FileOperationOutput';
  resource?: Maybe<Scalars['URI']>;
  target?: Maybe<IFileStatWithMetadata>;
  operation?: Maybe<IFileOperation>;
};

export const enum IFileOperationResult {
  FileIsDirectory = 'FILE_IS_DIRECTORY',
  FileNotFound = 'FILE_NOT_FOUND',
  FileNotModifiedSince = 'FILE_NOT_MODIFIED_SINCE',
  FileModifiedSince = 'FILE_MODIFIED_SINCE',
  FileMoveConflict = 'FILE_MOVE_CONFLICT',
  FileReadOnly = 'FILE_READ_ONLY',
  FilePermissionDenied = 'FILE_PERMISSION_DENIED',
  FileTooLarge = 'FILE_TOO_LARGE',
  FileInvalidPath = 'FILE_INVALID_PATH',
  FileExceedMemoryLimit = 'FILE_EXCEED_MEMORY_LIMIT',
  FileOtherError = 'FILE_OTHER_ERROR'
};

export type IFileOverwriteOptions = {
  __typename?: 'FileOverwriteOptions';
  overwrite: Scalars['Boolean'];
};

export type IFileQueryInput = {
  _reason?: Maybe<Scalars['String']>;
  folderQueries?: Maybe<Array<Maybe<IFolderQueryInput>>>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  excludePattern?: Maybe<Scalars['AnyObject']>;
  extraFileResources?: Maybe<Array<Maybe<Scalars['URIInput']>>>;
  useRipgrep?: Maybe<Scalars['Boolean']>;
  maxResults?: Maybe<Scalars['Int']>;
  usingSearchPaths?: Maybe<Scalars['Boolean']>;
  type: IQueryType;
  filePattern?: Maybe<Scalars['String']>;
  disregardExcludeSettings?: Maybe<Scalars['Boolean']>;
  exists?: Maybe<Scalars['Boolean']>;
  sortByScore?: Maybe<Scalars['Boolean']>;
  cacheKey?: Maybe<Scalars['String']>;
};

export type IFileResult = {
  __typename?: 'FileResult';
  source?: Maybe<Scalars['URI']>;
  target?: Maybe<Scalars['URI']>;
  success?: Maybe<Scalars['Boolean']>;
};

export type IFileSearchProviderStats = {
  __typename?: 'FileSearchProviderStats';
  providerTime?: Maybe<Scalars['Int']>;
  postProcessTime?: Maybe<Scalars['Int']>;
};

export type IFileSearchStats = {
  __typename?: 'FileSearchStats';
  fromCache?: Maybe<Scalars['Boolean']>;
  detailStats?: Maybe<IFileSearchStatsdetailStats>;
  resultCount?: Maybe<Scalars['Int']>;
  type?: Maybe<IFileSearchStatsType>;
  sortingTime?: Maybe<Scalars['Int']>;
};

export const enum IFileSearchStatsType {
  FileIndexProvider = 'fileIndexProvider',
  FileSearchProvider = 'fileSearchProvider',
  SearchProcess = 'searchProcess'
};

export type IFileSearchStatsdetailStats = ISearchEngineStats | ICachedSearchStats | IFileSearchProviderStats | IFileIndexProviderStats;

export type IFileStat = IIBaseStat & {
  __typename?: 'FileStat';
  resource: Scalars['URI'];
  name: Scalars['String'];
  size?: Maybe<Scalars['Int']>;
  mtime?: Maybe<Scalars['BigInt']>;
  etag?: Maybe<Scalars['String']>;
  isReadonly?: Maybe<Scalars['Boolean']>;
  /**  The resource is a directory  */
  isDirectory?: Maybe<Scalars['Boolean']>;
  /**  The resource is a symbolic link.  */
  isSymbolicLink?: Maybe<Scalars['Boolean']>;
  /**  The children of the file stat or undefined if none.  */
  children?: Maybe<Array<Maybe<IFileStat>>>;
};

/** Its extension of IFileStat and IBaseStatWithMetadata */
export type IFileStatWithMetadata = IIBaseStat & IIBaseStatWithMetadata & IIContentChangedEvent & IIFileClientMetadata & IITreeItem & IIUntitledFileValue & {
  __typename?: 'FileStatWithMetadata';
  active?: Maybe<Scalars['Boolean']>;
  changes?: Maybe<Scalars['JSON']>;
  /**  The children of the file stat or undefined if none.  */
  children?: Maybe<Array<Maybe<IFileStatWithMetadata>>>;
  childrenGen?: Maybe<Array<Maybe<IFileStatWithMetadata>>>;
  /** Content of the file is modified */
  dirty?: Maybe<Scalars['Boolean']>;
  /** encoding as reported from disk if the file is text */
  encoding?: Maybe<Scalars['String']>;
  eol?: Maybe<Scalars['String']>;
  etag: Scalars['String'];
  expanded?: Maybe<Scalars['Boolean']>;
  hasChildren?: Maybe<Scalars['Boolean']>;
  /** File is in conflict with storage. */
  inConflictMode?: Maybe<Scalars['Boolean']>;
  /** File is in Error */
  inErrorMode?: Maybe<Scalars['Boolean']>;
  /** File doesn't exist in the storage */
  inOrphanMode?: Maybe<Scalars['Boolean']>;
  /** Pending Save */
  inPendingSave?: Maybe<Scalars['Boolean']>;
  isDirectory?: Maybe<Scalars['Boolean']>;
  isEmpty?: Maybe<Scalars['Boolean']>;
  isFlush?: Maybe<Scalars['Boolean']>;
  isReadonly?: Maybe<Scalars['Boolean']>;
  isRedoing?: Maybe<Scalars['Boolean']>;
  /**  The resource is a symbolic link.  */
  isSymbolicLink?: Maybe<Scalars['Boolean']>;
  isUndoing?: Maybe<Scalars['Boolean']>;
  mtime: Scalars['BigInt'];
  name: Scalars['String'];
  path?: Maybe<Scalars['String']>;
  preferredEncoding?: Maybe<Scalars['String']>;
  preferredMode?: Maybe<Scalars['String']>;
  resource: Scalars['URI'];
  resourcePath?: Maybe<Scalars['String']>;
  size: Scalars['Int'];
  state?: Maybe<IFileModelState>;
  subtitle?: Maybe<Scalars['String']>;
  title?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['String']>;
  versionId?: Maybe<Scalars['Int']>;
};

export const enum IFileStateChange {
  Dirty = 'DIRTY',
  Saving = 'SAVING',
  SaveError = 'SAVE_ERROR',
  Saved = 'SAVED',
  Reverted = 'REVERTED',
  Encoding = 'ENCODING',
  ContentChange = 'CONTENT_CHANGE',
  OrphanedChange = 'ORPHANED_CHANGE'
};

export type IFileStreamContent = IIBaseStatWithMetadata & IIBaseStat & {
  __typename?: 'FileStreamContent';
  resource: Scalars['URI'];
  name: Scalars['String'];
  mtime: Scalars['BigInt'];
  etag: Scalars['String'];
  size: Scalars['Int'];
  isReadonly?: Maybe<Scalars['Boolean']>;
  value?: Maybe<Scalars['VSBufferReadableStream']>;
};

export type IFileToOpen = {
  __typename?: 'FileToOpen';
  fileUri?: Maybe<Scalars['URI']>;
  label?: Maybe<Scalars['String']>;
};

export const enum IFileType {
  Unknown = 'Unknown',
  File = 'File',
  Directory = 'Directory',
  SymbolicLink = 'SymbolicLink'
};

export type IFileWriteOptions = {
  __typename?: 'FileWriteOptions';
  overwrite: Scalars['Boolean'];
  create: Scalars['Boolean'];
};

export type IFiles = {
  __typename?: 'Files';
  eol?: Maybe<Scalars['String']>;
  hotExit?: Maybe<Scalars['String']>;
  encoding?: Maybe<Scalars['String']>;
  autoSave?: Maybe<IAutoSaveConfigurationType>;
  autoSaveDelay?: Maybe<Scalars['Int']>;
  defaultLanguage?: Maybe<Scalars['String']>;
  autoGuessEncoding?: Maybe<Scalars['Boolean']>;
  insertFinalNewline?: Maybe<Scalars['Boolean']>;
  trimTrailingWhitespace?: Maybe<Scalars['Boolean']>;
  useExperimentalFileWatcher?: Maybe<Scalars['Boolean']>;
  watcherExclude?: Maybe<Scalars['JSON']>;
  exclude?: Maybe<Scalars['JSON']>;
};

export type IFiles_Stat = {
  __typename?: 'Files_Stat';
  type?: Maybe<IFileType>;
  mtime?: Maybe<Scalars['BigInt']>;
  ctime?: Maybe<Scalars['BigInt']>;
  size?: Maybe<Scalars['Int']>;
};

export type IFolderConfigurationModel = {
  __typename?: 'FolderConfigurationModel';
  id: Scalars['String'];
  contents?: Maybe<Scalars['AnyObject']>;
  keys?: Maybe<Array<Maybe<Scalars['String']>>>;
  overrides?: Maybe<IConfigurationOverrides>;
};

export type IFolderInput = {
  uri: Scalars['URI'];
  name?: Maybe<Scalars['String']>;
};

export type IFolderQuery = {
  __typename?: 'FolderQuery';
  folder: Scalars['URI'];
  excludePattern?: Maybe<Scalars['AnyObject']>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  fileEncoding?: Maybe<Scalars['String']>;
  disregardIgnoreFiles?: Maybe<Scalars['Boolean']>;
};

export type IFolderQueryInput = {
  folder: Scalars['URIInput'];
  excludePattern?: Maybe<Scalars['AnyObject']>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  fileEncoding?: Maybe<Scalars['String']>;
  disregardIgnoreFiles?: Maybe<Scalars['Boolean']>;
};

export type IFolderSettings = IISettingsSubject & {
  __typename?: 'FolderSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IFolderToOpen = {
  __typename?: 'FolderToOpen';
  folderUri?: Maybe<Scalars['URI']>;
  label?: Maybe<Scalars['String']>;
};

export type IFoldersToAdd_Input = {
  uri: Scalars['URI'];
  name?: Maybe<Scalars['String']>;
};

export type IGalleryBanner = {
  __typename?: 'GalleryBanner';
  color?: Maybe<Scalars['String']>;
  theme?: Maybe<Scalars['String']>;
};

export type IGalleryExtension = {
  __typename?: 'GalleryExtension';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  identifier?: Maybe<IExtensionIdentifier>;
  version?: Maybe<Scalars['String']>;
  date?: Maybe<Scalars['String']>;
  icon?: Maybe<Scalars['String']>;
  displayName?: Maybe<Scalars['String']>;
  publisherId?: Maybe<Scalars['String']>;
  publisher?: Maybe<Scalars['String']>;
  publisherDisplayName?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  installCount?: Maybe<Scalars['Int']>;
  rating?: Maybe<Scalars['Float']>;
  ratingCount?: Maybe<Scalars['Float']>;
  assets?: Maybe<IGalleryExtensionAssets>;
  properties?: Maybe<IGalleryExtensionProperties>;
  preview?: Maybe<Scalars['Boolean']>;
  resources?: Maybe<IGalleryExtensionResources>;
};

export type IGalleryExtensionAsset = {
  __typename?: 'GalleryExtensionAsset';
  uri?: Maybe<Scalars['String']>;
  fallbackUri?: Maybe<Scalars['String']>;
};

export type IGalleryExtensionAssets = {
  __typename?: 'GalleryExtensionAssets';
  manifest?: Maybe<IGalleryExtensionAsset>;
  readme?: Maybe<IGalleryExtensionAsset>;
  changelog?: Maybe<IGalleryExtensionAsset>;
  download?: Maybe<IGalleryExtensionAsset>;
  icon?: Maybe<IGalleryExtensionAsset>;
  license?: Maybe<IGalleryExtensionAsset>;
  repository?: Maybe<IGalleryExtensionAsset>;
  coreTranslations?: Maybe<Scalars['JSON']>;
};

export type IGalleryExtensionProperties = {
  __typename?: 'GalleryExtensionProperties';
  engine?: Maybe<Scalars['String']>;
  dependencies?: Maybe<Array<Maybe<Scalars['String']>>>;
  extensionPack?: Maybe<Array<Maybe<Scalars['String']>>>;
  localizedLanguages?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IGalleryExtensionResources = {
  __typename?: 'GalleryExtensionResources';
  manifest?: Maybe<Scalars['String']>;
  readme?: Maybe<Scalars['String']>;
  changelog?: Maybe<Scalars['String']>;
  download?: Maybe<Scalars['String']>;
  icon?: Maybe<Scalars['String']>;
  license?: Maybe<Scalars['String']>;
  repository?: Maybe<Scalars['String']>;
};

export type IGalleryFilter = {
  value?: Maybe<Scalars['String']>;
  filterType?: Maybe<Scalars['String']>;
};

export type IGalleryPager = {
  __typename?: 'GalleryPager';
  page?: Maybe<Scalars['Int']>;
  total?: Maybe<Scalars['Int']>;
  pageSize?: Maybe<Scalars['Int']>;
  firstPage?: Maybe<Array<Maybe<IGalleryExtension>>>;
};

export type IGalleryQueryInput = {
  text?: Maybe<Scalars['String']>;
  ids?: Maybe<Array<Maybe<Scalars['String']>>>;
  names?: Maybe<Array<Maybe<Scalars['String']>>>;
  pageSize?: Maybe<Scalars['Int']>;
  sortBy?: Maybe<Scalars['Int']>;
  sortOrder?: Maybe<Scalars['Int']>;
  source?: Maybe<Scalars['String']>;
};

export type IGeoLocation = {
  __typename?: 'GeoLocation';
  coordinates?: Maybe<Array<Maybe<Scalars['Float']>>>;
};

export type IGit = {
  __typename?: 'Git';
  path?: Maybe<Scalars['String']>;
  enabled?: Maybe<Scalars['Boolean']>;
  autofetch?: Maybe<Scalars['Boolean']>;
  countBadge?: Maybe<Scalars['String']>;
  autorefresh?: Maybe<Scalars['Boolean']>;
  confirmSync?: Maybe<Scalars['Boolean']>;
  checkoutType?: Maybe<Scalars['String']>;
  inputValidation?: Maybe<Scalars['String']>;
  detectSubmodules?: Maybe<Scalars['Boolean']>;
  enableSmartCommit?: Maybe<Scalars['Boolean']>;
  ignoreLimitWarning?: Maybe<Scalars['Boolean']>;
  ignoreLegacyWarning?: Maybe<Scalars['Boolean']>;
  enableCommitSigning?: Maybe<Scalars['Boolean']>;
  defaultCloneDirectory?: Maybe<Scalars['String']>;
  autoRepositoryDetection?: Maybe<Scalars['Boolean']>;
  ignoreMissingGitWarning?: Maybe<Scalars['Boolean']>;
  showInlineOpenFileAction?: Maybe<Scalars['Boolean']>;
  promptToSaveFilesBeforeCommit?: Maybe<Scalars['Boolean']>;
  decorations?: Maybe<IGitDecorations>;
};

export type IGitDecorations = {
  __typename?: 'GitDecorations';
  enabled?: Maybe<Scalars['Boolean']>;
};

export type IGlobalSettings = IISettingsSubject & {
  __typename?: 'GlobalSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings.  */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IGoToLineQuickAccess = {
  __typename?: 'GoToLineQuickAccess';
  range?: Maybe<ILineRange>;
  highlight?: Maybe<Scalars['Boolean']>;
  focus?: Maybe<Scalars['Boolean']>;
};

export type IGrammar = {
  __typename?: 'Grammar';
  language?: Maybe<Scalars['String']>;
};

export const enum IGraphqlCallType {
  Mutation = 'mutation',
  Query = 'query'
};

export { GroupDirection };

export type IGroupLayoutArgument = {
  __typename?: 'GroupLayoutArgument';
  size?: Maybe<Scalars['Int']>;
  groups?: Maybe<Array<Maybe<IGroupLayoutArgument>>>;
};

export { GroupLocation };

export { GroupOrientation };

export { GroupsArrangement };

export { GroupsOrder };

export const enum IHotExitConfiguration {
  Off = 'OFF',
  OnExit = 'ON_EXIT',
  OnExitAndWindowClose = 'ON_EXIT_AND_WINDOW_CLOSE'
};

export type IHover = {
  contents?: Maybe<IMarkupContent>;
  range?: Maybe<IRange>;
};

export type IIActivationRequest = {
  env?: Maybe<Array<Maybe<Scalars['String']>>>;
  extensionID: Scalars['ID'];
};

export type IIBaseStat = {
  /**  The unified resource identifier of this file or folder  */
  resource: Scalars['URI'];
  /**
   * The name which is the last segement
   * of the {{path}}
   */
  name: Scalars['String'];
  /**
   * The size of the file.
   *
   * The value may or may not be resolved as
   * it is optional.
   */
  size?: Maybe<Scalars['Int']>;
  /**
   * The last modification date represented
   * as millis from unix epoch.
   *
   * The value may or may not be resolved as
   * it is optional.
   */
  mtime?: Maybe<Scalars['BigInt']>;
  /**
   * A unique identifier that represents the
   * current state of the file or directory.
   *
   * The value may or may not be resolved as
   * it is optional
   */
  etag?: Maybe<Scalars['String']>;
  /**  The resource is readonly.  */
  isReadonly?: Maybe<Scalars['Boolean']>;
};

/** Extension of IBaseStat with few more fields */
export type IIBaseStatWithMetadata = {
  mtime: Scalars['BigInt'];
  etag: Scalars['String'];
  size: Scalars['Int'];
};

/** # extension of IBaseStatWithMetadata */
export type IIBaseTextFileContent = {
  /** The encoding of the content if known. */
  encoding?: Maybe<Scalars['String']>;
};

export type IIBehaviorSubject = {
  __typename?: 'IBehaviorSubject';
  closed?: Maybe<Scalars['Boolean']>;
  hasError?: Maybe<Scalars['Boolean']>;
  isStopped?: Maybe<Scalars['Boolean']>;
  observers?: Maybe<Array<Maybe<Scalars['JSON']>>>;
  thrownError?: Maybe<Scalars['String']>;
  _isScalar?: Maybe<Scalars['Boolean']>;
  value?: Maybe<Array<Maybe<IIBehaviorSubjectValue>>>;
};

export type IIBehaviorSubjectValue = {
  __typename?: 'IBehaviorSubjectValue';
  provider?: Maybe<Scalars['String']>;
  registrationOptions?: Maybe<IIDocumentSelector>;
};

/** A set of search paths and a set of glob expressions that should be applied. */
export type IICommonQueryProps = {
  _reason?: Maybe<Scalars['String']>;
  folderQueries?: Maybe<Array<Maybe<IFolderQuery>>>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  excludePattern?: Maybe<Scalars['AnyObject']>;
  extraFileResources?: Maybe<Array<Maybe<Scalars['URI']>>>;
  useRipgrep?: Maybe<Scalars['Boolean']>;
  maxResults?: Maybe<Scalars['Int']>;
  usingSearchPaths?: Maybe<Scalars['Boolean']>;
};

export type IIConfigurationChangeEvent = {
  __typename?: 'IConfigurationChangeEvent';
  source?: Maybe<ConfigurationTarget>;
  affectedKeys?: Maybe<Array<Maybe<Scalars['String']>>>;
  sourceConfig?: Maybe<Scalars['AnyObject']>;
  changedConfiguration?: Maybe<IConfigurationModel>;
  changedConfigurationByResource?: Maybe<IResourceMapConfigurationModel>;
};

export type IIConfigurationService = {
  updateValue?: Maybe<Scalars['Boolean']>;
};


export type IIConfigurationServiceUpdateValueArgs = {
  key: Scalars['String'];
  value: Scalars['AnyObject'];
  overrides: IConfigurationOverrides_Input;
  target?: Maybe<ConfigurationTarget>;
  donotNotifyError?: Maybe<Scalars['Boolean']>;
};

export type IIContentChangedEvent = {
  changes?: Maybe<Scalars['JSON']>;
  eol?: Maybe<Scalars['String']>;
  versionId?: Maybe<Scalars['Int']>;
  isUndoing?: Maybe<Scalars['Boolean']>;
  isRedoing?: Maybe<Scalars['Boolean']>;
  isFlush?: Maybe<Scalars['Boolean']>;
};

export type IIDebugParams = {
  port?: Maybe<Scalars['Int']>;
  break?: Maybe<Scalars['Boolean']>;
};

export type IIDestinationAnonymousSubject = {
  __typename?: 'IDestinationAnonymousSubject';
  closed?: Maybe<Scalars['Boolean']>;
  destination?: Maybe<Scalars['String']>;
  hasError?: Maybe<Scalars['Boolean']>;
  isStopped?: Maybe<Scalars['Boolean']>;
  observers?: Maybe<Array<Maybe<Scalars['JSON']>>>;
  operator?: Maybe<IISwitchMapOperator>;
  source?: Maybe<IIBehaviorSubject>;
  thrownError?: Maybe<Scalars['String']>;
  _isScalar?: Maybe<Scalars['Boolean']>;
};

export type IIDocumentSelector = {
  __typename?: 'IDocumentSelector';
  documentSelector?: Maybe<Scalars['JSON']>;
};

/** EditorGroup that has fields borrowed from vscode. */
export type IIEditorGroup = {
  /**
   * A unique identifier of this group that remains identical even if the
   * group is moved to different locations.
   */
  id: Scalars['Int'];
  /**
   * A human readable lable for the group. This label can change depending
   * on the layout of all editor groups. Clients should listen to this event
   * to react to that.
   */
  label?: Maybe<Scalars['String']>;
};

export type IIEditorInput = {
  /** Returns the associated resource of this input. */
  resource?: Maybe<Scalars['String']>;
  /** Unique type identifier for this input. */
  typeId?: Maybe<IEditor_Input_Id>;
  /** Returns the display title of this input. */
  label?: Maybe<Scalars['String']>;
  /**
   * Returns the display description of this input that can be shown to the user. Examples include showing the desciption of
   * the input about the editor area to the side of the name of the input.
   */
  description?: Maybe<Scalars['String']>;
  /**
   * File referenced in the Editor Input to provide
   * `isDirty`, `name`
   */
  fileReference?: Maybe<IFileStatWithMetadata>;
  /**
   * Returns the preferred editor for this input. A list of candidate editors is passed in that we registered
   * for the input. This allows subclasses to decide later which editor to use for the input on a case by case basis.
   */
  preferredEditorId?: Maybe<Scalars['String']>;
  /** Set this to false if it does not make sense to split the editor input. */
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
};

/**
 * Additional details to EditorInput to help to resolve fields that
 * helps IEditorGroup
 */
export type IIEditorInputWithGroupFields = {
  /**
   * File is currently active.
   * Note: An editor can be opened but not actively visible.
   */
  isActive?: Maybe<Scalars['Boolean']>;
  /**
   * The editor is pinned in the group. A pinned editor is not replaced
   * when another editor opens at the same location.
   */
  isPinned?: Maybe<Scalars['Boolean']>;
  /**
   * The editor in the group that is in preview mode if any. There can
   * only ever be one editor in preview mode.
   */
  preview?: Maybe<Scalars['Boolean']>;
  /** custom id to map to the EditorGroup it belongs */
  editorId?: Maybe<Scalars['Int']>;
  /**
   * File loading status
   * @deprecated - We can use IFileStat to have it.
   */
  status?: Maybe<Scalars['String']>;
  /**
   * @docklayout
   * Whether this tab is closable
   */
  closable?: Maybe<Scalars['Boolean']>;
};

export type IIEncodingSupport = {
  /** encoding for the input for saving. */
  encoding?: Maybe<Scalars['String']>;
};

export type IIFileClientMetadata = {
  /** Content of the file is modified */
  dirty?: Maybe<Scalars['Boolean']>;
  /** File is in conflict with storage. */
  inConflictMode?: Maybe<Scalars['Boolean']>;
  /** File doesn't exist in the storage */
  inOrphanMode?: Maybe<Scalars['Boolean']>;
  /** File is in Error */
  inErrorMode?: Maybe<Scalars['Boolean']>;
  /** Pending Save */
  inPendingSave?: Maybe<Scalars['Boolean']>;
  preferredMode?: Maybe<Scalars['String']>;
  encoding?: Maybe<Scalars['String']>;
  preferredEncoding?: Maybe<Scalars['String']>;
  state?: Maybe<IFileModelState>;
};

/**
 * This is a tagging interface to declare an editor input being capable of dealing with files. It is only used in the editor registry
 * to register this kind of input to the platform.
 *
 * As a workaround to https://github.com/graphql/graphql-spec/pull/373, we will be add additional interfaces as sub-fields.
 */
export type IIFileEditorInput = {
  /** Preferred encoding to use for this input. */
  preferredEncoding?: Maybe<Scalars['String']>;
  /** Preferred mode to use for this input. */
  preferredMode?: Maybe<Scalars['String']>;
  /** Forces the file input to open as binary instead of text. */
  forceOpenAsBinary?: Maybe<Scalars['Boolean']>;
};

export type IIFileMatch = {
  resource?: Maybe<Scalars['URI']>;
  results?: Maybe<Array<Maybe<ITextSearchResult>>>;
};

export type IIFileSystemProviderActivationEvent = {
  scheme: Scalars['String'];
};

export type IIFileSystemProviderRegistrationEvent = {
  added: Scalars['Boolean'];
  scheme: Scalars['String'];
};

export type IIjsonValueInput = {
  key?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['AnyObject']>;
};

export type IIModeSupport = {
  /** language mode of the input. */
  mode?: Maybe<Scalars['String']>;
};

export type IIModel = {
  __typename?: 'IModel';
  roots?: Maybe<IIWorkspaceRoot>;
  visibleViewComponents?: Maybe<Array<Maybe<IIViewComponentData>>>;
};

export type IIModelInput = {
  roots?: Maybe<IIWorkspaceRootInput>;
  visibleViewComponents?: Maybe<Array<Maybe<IIViewComponentDataInput>>>;
};

export type IIObservableResult = {
  __typename?: 'IObservableResult';
  closed?: Maybe<Scalars['Boolean']>;
  destination?: Maybe<IIDestinationAnonymousSubject>;
  hasError?: Maybe<Scalars['Boolean']>;
  isStopped?: Maybe<Scalars['Boolean']>;
  observers?: Maybe<Array<Maybe<Scalars['JSON']>>>;
  operator?: Maybe<IISwitchMapOperator>;
  source?: Maybe<IISourceAnonymousSubject>;
  thrownError?: Maybe<Scalars['String']>;
  _isScalar?: Maybe<Scalars['Boolean']>;
};

export type IIPathData = {
  /**  the file path to open within the instance  */
  fileUri?: Maybe<Scalars['URI']>;
  /**  the line number in the file path to open  */
  lineNumber?: Maybe<Scalars['Int']>;
  /**  the column number in the file path to open  */
  columnNumber?: Maybe<Scalars['Int']>;
  /**
   * a hint that the file exists. If true, the file exists, if false it does not. within
   * undefined the state is uknown.
   */
  exists?: Maybe<Scalars['Boolean']>;
};

export type IIPathsToWaitForData = {
  paths?: Maybe<Array<Maybe<IIPathData>>>;
  waitMarkerFileUri?: Maybe<Scalars['URI']>;
};

export type IIResourceUtilizationSettings = {
  subTopic?: Maybe<Scalars['String']>;
  adminApiNamespace?: Maybe<Scalars['String']>;
};

export type IISearchCompleteStats = {
  limitHit?: Maybe<Scalars['Boolean']>;
  stats?: Maybe<ISearchCompleteStatsStats>;
};

export type IISearchProgress = {
  total?: Maybe<Scalars['Int']>;
  worked?: Maybe<Scalars['Int']>;
  message?: Maybe<Scalars['String']>;
};

/**
 * ISettingsSubject is something that can have settings: a site ("global settings", which is different from "site
 * configuration"), an organization, or a user.
 */
export type IISettingsSubject = {
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings.  */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IISideBySideEditorInput = {
  master?: Maybe<IEditorInput>;
  details?: Maybe<IEditorInput>;
};

export type IISourceAnonymousSubject = {
  __typename?: 'ISourceAnonymousSubject';
  closed?: Maybe<Scalars['Boolean']>;
  destination?: Maybe<IIDestinationAnonymousSubject>;
  hasError?: Maybe<Scalars['Boolean']>;
  isStopped?: Maybe<Scalars['Boolean']>;
  observers?: Maybe<Array<Maybe<Scalars['JSON']>>>;
  operator?: Maybe<IISwitchMapOperator>;
  source?: Maybe<IIBehaviorSubject>;
  thrownError?: Maybe<Scalars['String']>;
  _isScalar?: Maybe<Scalars['Boolean']>;
};

export type IIStaticWorkspaceData = {
  id: Scalars['String'];
  name?: Maybe<Scalars['String']>;
  configuration?: Maybe<Scalars['URI']>;
  isUntitled?: Maybe<Scalars['Boolean']>;
};

export type IIStatusbarItem = {
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type IISwitchMapOperator = {
  __typename?: 'ISwitchMapOperator';
  project?: Maybe<Scalars['String']>;
};

export type IITextDocumentIdentifier = {
  uri?: Maybe<Scalars['URI']>;
  /** just to statisfy few issues */
  languageId?: Maybe<Scalars['String']>;
};

/** Tree data that compatible with `react-sortable-tree` package */
export type IITreeItem = {
  path?: Maybe<Scalars['String']>;
  title?: Maybe<Scalars['String']>;
  subtitle?: Maybe<Scalars['String']>;
  isDirectory?: Maybe<Scalars['Boolean']>;
  active?: Maybe<Scalars['Boolean']>;
  expanded?: Maybe<Scalars['Boolean']>;
  hasChildren?: Maybe<Scalars['Boolean']>;
  /** Helps to populate data before the directory or file created. */
  isEmpty?: Maybe<Scalars['Boolean']>;
};

export type IIUntitledFileValue = {
  value?: Maybe<Scalars['String']>;
};

export type IIUserPreferences = {
  __typename?: 'IUserPreferences';
  content?: Maybe<Scalars['String']>;
  user?: Maybe<Scalars['String']>;
};

export type IIUserSettings = {
  __typename?: 'IUserSettings';
  data?: Maybe<Scalars['String']>;
};

export type IIViewComponentData = {
  __typename?: 'IViewComponentData';
  type?: Maybe<Scalars['String']>;
  item?: Maybe<ITextDocumentItem>;
  isActive?: Maybe<Scalars['Boolean']>;
};

export type IIViewComponentDataInput = {
  type?: Maybe<Scalars['String']>;
  item?: Maybe<ITextDocumentItemInput>;
  isActive?: Maybe<Scalars['Boolean']>;
};

export type IIViewDescriptor = {
  id: Scalars['String'];
  name?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  order?: Maybe<Scalars['Int']>;
  weight?: Maybe<Scalars['Int']>;
  collapsed?: Maybe<Scalars['Boolean']>;
  canToggleVisibility?: Maybe<Scalars['Boolean']>;
  hideByDefault?: Maybe<Scalars['Boolean']>;
  workspace?: Maybe<Scalars['Boolean']>;
};

export type IIWorkspaceRoot = {
  __typename?: 'IWorkspaceRoot';
  url?: Maybe<Scalars['String']>;
};

export type IIWorkspaceRootInput = {
  url?: Maybe<Scalars['String']>;
};

export type IImportResult = {
  __typename?: 'ImportResult';
  stat?: Maybe<IFileStat>;
  isNew?: Maybe<Scalars['Boolean']>;
};

export type IIndentation = IIStatusbarItem & {
  __typename?: 'Indentation';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type IInputOptions = {
  title?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['String']>;
  prompt?: Maybe<Scalars['String']>;
  placeHolder?: Maybe<Scalars['String']>;
  password?: Maybe<Scalars['Boolean']>;
  validationMessage?: Maybe<Scalars['String']>;
};

export type IInputTypeDetail = {
  __typename?: 'InputTypeDetail';
  type?: Maybe<Scalars['String']>;
  options?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IInputTypeDetailInput = {
  type?: Maybe<Scalars['String']>;
  options?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IInstalledExtension = {
  __typename?: 'InstalledExtension';
  extension?: Maybe<IGalleryExtension>;
  identifier?: Maybe<IExtensionIdentifier>;
  galleryIdentifier?: Maybe<IExtensionIdentifier>;
};

export type IIntegrated = {
  __typename?: 'Integrated';
  setLocaleVariables?: Maybe<Scalars['Boolean']>;
  shellArgs?: Maybe<IShellArgs>;
  shell?: Maybe<IShell>;
};



export type IKeepOpen_Input = {
  resource: Scalars['String'];
  editorId?: Maybe<Scalars['Int']>;
  name?: Maybe<Scalars['String']>;
};

export type IKeyBinding = {
  __typename?: 'KeyBinding';
  command?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  mac?: Maybe<Scalars['String']>;
  linux?: Maybe<Scalars['String']>;
  win?: Maybe<Scalars['String']>;
};

/**
 * A segment of a key path that locates a nested JSON value in a root JSON value. Exactly one field in each
 * KeyPathSegment must be non-null.
 *
 * For example, in {"a": [0, {"b": 3}]}, the value 3 is located at the key path ["a", 1, "b"].
 */
export type IKeyPathSegment = {
  /**  The name of the property in the object at this location to descend into.  */
  property?: Maybe<Scalars['String']>;
  /**  The index of the array at this location to descend into.  */
  index?: Maybe<Scalars['Int']>;
};

export type IKeybindingContextMenu = {
  __typename?: 'KeybindingContextMenu';
  editItem?: Maybe<IEditKeybindingItem>;
  selectedItemIndex?: Maybe<Scalars['Int']>;
  editWhenIndex?: Maybe<Scalars['Int']>;
  newWhen?: Maybe<Scalars['String']>;
  isOpenDialog?: Maybe<Scalars['Boolean']>;
  search?: Maybe<Scalars['String']>;
};

export type IKeybindingEditorInput = IIEditorInput & IIEditorInputWithGroupFields & {
  __typename?: 'KeybindingEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
};

export type IKeybindingInput = {
  command?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  source?: Maybe<Scalars['String']>;
  run?: Maybe<IActionRunInput>;
};

export type IKeybindingItem = {
  __typename?: 'KeybindingItem';
  command?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  source?: Maybe<IKeybindingSource>;
  run?: Maybe<IActionRun>;
};

export type IKeybindingItemInput = {
  command: Scalars['String'];
  key: Scalars['String'];
  when?: Maybe<Scalars['String']>;
  args?: Maybe<Scalars['AnyObject']>;
  isDefault?: Maybe<Scalars['Boolean']>;
};

export const enum IKeybindingSource {
  Default = 'Default',
  User = 'User'
};

export type IKeybindings = {
  __typename?: 'Keybindings';
  items?: Maybe<Array<Maybe<IKeybindingItem>>>;
};

export type IKeyboardEventInput = {
  ctrlKey?: Maybe<Scalars['Boolean']>;
  shiftKey?: Maybe<Scalars['Boolean']>;
  altKey?: Maybe<Scalars['Boolean']>;
  metaKey?: Maybe<Scalars['Boolean']>;
  keyCode?: Maybe<Scalars['Int']>;
  code?: Maybe<Scalars['String']>;
  browserEvent?: Maybe<Scalars['AnyObject']>;
};

export type IKeyboardEvent_Output = {
  __typename?: 'KeyboardEvent_output';
  label?: Maybe<Scalars['String']>;
  key?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export { LableFormatType };

export type ILanguageMode = IIStatusbarItem & {
  __typename?: 'LanguageMode';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type ILanguages = {
  __typename?: 'Languages';
  go?: Maybe<Scalars['Boolean']>;
  css?: Maybe<Scalars['Boolean']>;
  html?: Maybe<Scalars['Boolean']>;
  json?: Maybe<Scalars['Boolean']>;
  yaml?: Maybe<Scalars['Boolean']>;
  typescript?: Maybe<Scalars['Boolean']>;
  javascript?: Maybe<Scalars['Boolean']>;
};

export type ILineMatch = {
  __typename?: 'LineMatch';
  preview?: Maybe<Scalars['String']>;
  lineNumber?: Maybe<Scalars['Int']>;
  offsetAndLengths?: Maybe<Array<Maybe<Array<Maybe<Scalars['Int']>>>>>;
  part?: Maybe<Scalars['Int']>;
};

export type ILineRange = {
  __typename?: 'LineRange';
  endColumn?: Maybe<Scalars['Int']>;
  endLine?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  startLine?: Maybe<Scalars['Int']>;
};

export type ILineRangeInput = {
  startLine?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  endLine?: Maybe<Scalars['Int']>;
  endColumn?: Maybe<Scalars['Int']>;
};

export type ILoadOptions_Input = {
  /**  Go to disk bypassing any cahce of the model if any. */
  forceReadFromDisk?: Maybe<Scalars['Boolean']>;
  /**  Allow to load a model even if we think it is a binary file. */
  allowBinary?: Maybe<Scalars['Boolean']>;
  /**  Context why the model is being loaded. */
  reason?: Maybe<IFileLoadReason>;
};

export type ILocalUserSettings = IISettingsSubject & {
  __typename?: 'LocalUserSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type ILocalization = {
  __typename?: 'Localization';
  languageId?: Maybe<Scalars['String']>;
  languageName?: Maybe<Scalars['String']>;
  localizedLanguageName?: Maybe<Scalars['String']>;
  translations?: Maybe<Array<Maybe<ILocalizationTranslation>>>;
  minimalTranslations?: Maybe<Scalars['JSON']>;
};

export type ILocalizationTranslation = {
  __typename?: 'LocalizationTranslation';
  id?: Maybe<Scalars['ID']>;
  path?: Maybe<Scalars['String']>;
};

/**
 * Represents a location inside a resource, such as a line
 * inside a text file.
 */
export type ILocation = {
  rangeOrUri?: Maybe<IPosition>;
  uriRangeOrPosition?: Maybe<Scalars['String']>;
  range?: Maybe<IPosition>;
  uri?: Maybe<Scalars['String']>;
};

export type IMarkupContent = {
  value?: Maybe<Scalars['String']>;
  kind?: Maybe<IMarkupKind>;
};

export const enum IMarkupKind {
  Plaintext = 'plaintext',
  Markdown = 'markdown'
};

export type IMatch = {
  __typename?: 'Match';
  start?: Maybe<Scalars['Int']>;
  end?: Maybe<Scalars['Int']>;
};

export type IMatchInput = {
  start?: Maybe<Scalars['Int']>;
  end?: Maybe<Scalars['Int']>;
};

export type IMemorySettings = IISettingsSubject & {
  __typename?: 'MemorySettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export const enum IMenuId {
  CommandPalette = 'CommandPalette',
  DebugBreakpointsContext = 'DebugBreakpointsContext',
  DebugCallStackContext = 'DebugCallStackContext',
  DebugConsoleContext = 'DebugConsoleContext',
  DebugVariablesContext = 'DebugVariablesContext',
  DebugWatchContext = 'DebugWatchContext',
  DebugTooBar = 'DebugTooBar',
  EditorContext = 'EditorContext',
  EditorTitle = 'EditorTitle',
  EditorTitleContext = 'EditorTitleContext',
  EmptyEditorGroupContext = 'EmptyEditorGroupContext',
  ExplorerContext = 'ExplorerContext',
  MenubarAppearanceMenu = 'MenubarAppearanceMenu',
  MenubarDebugMenu = 'MenubarDebugMenu',
  MenubarEditMenu = 'MenubarEditMenu',
  MenubarFileMenu = 'MenubarFileMenu',
  MenubarGoMenu = 'MenubarGoMenu',
  MenubarNewBreakpointMenu = 'MenubarNewBreakpointMenu',
  MenubarPreferencesMenu = 'MenubarPreferencesMenu',
  MenubarRecentMenu = 'MenubarRecentMenu',
  MenubarSelectionMenu = 'MenubarSelectionMenu',
  MenubarSwitchEditorMenu = 'MenubarSwitchEditorMenu',
  MenubarSwitchGroupMenu = 'MenubarSwitchGroupMenu',
  MenubarTerminalMenu = 'MenubarTerminalMenu',
  MenubarViewMenu = 'MenubarViewMenu',
  OpenEditorContext = 'OpenEditorContext',
  ProblemsPanelContext = 'ProblemsPanelContext',
  ScmChangeContext = 'SCMChangeContext',
  ScmResourceContext = 'SCMResourceContext',
  ScmResourceGroupContext = 'SCMResourceGroupContext',
  ScmResourceControl = 'SCMResourceControl',
  ScmTitle = 'SCMTitle',
  SearchContext = 'SearchContext',
  StatusBarWindowIndicatorMenu = 'StatusBarWindowIndicatorMenu',
  TouchBarContext = 'TouchBarContext',
  ViewItemContext = 'ViewItemContext',
  ViewTitle = 'ViewTitle',
  CommentThreadTitle = 'CommentThreadTitle',
  CommentThreadActions = 'CommentThreadActions',
  CommentTitle = 'CommentTitle',
  CommentActions = 'CommentActions'
};

export type IMenuItem = {
  __typename?: 'MenuItem';
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  enabled?: Maybe<Scalars['Boolean']>;
  run?: Maybe<IActionRun>;
};

export type IMenuItemAction = {
  __typename?: 'MenuItemAction';
  action?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
};

export type IMenuItemActionContext = {
  __typename?: 'MenuItemActionContext';
  context?: Maybe<Array<Maybe<IMenuItemAction>>>;
};

export type IMenuItemActionDebug = {
  __typename?: 'MenuItemActionDebug';
  callstack?: Maybe<IMenuItemActionContext>;
  toolbar?: Maybe<Array<Maybe<IMenuItemAction>>>;
};

export type IMenuItemActionEditor = {
  __typename?: 'MenuItemActionEditor';
  context?: Maybe<Array<Maybe<IMenuItemAction>>>;
  title?: Maybe<IMenuItemActionEditorTitle>;
};

export type IMenuItemActionEditorTitle = {
  __typename?: 'MenuItemActionEditorTitle';
  own?: Maybe<Array<Maybe<IMenuItemAction>>>;
  context?: Maybe<Array<Maybe<IMenuItemAction>>>;
};

export type IMenuItemActionScm = {
  __typename?: 'MenuItemActionScm';
  /**  The Source Control title menu  */
  title?: Maybe<Array<Maybe<IMenuItemAction>>>;
  /**  The Source Control resource group context menu  */
  resourceGroup?: Maybe<IMenuItemActionContext>;
  resource?: Maybe<IMenuItemActionContext>;
  change?: Maybe<IMenuItemActionScmChange>;
};

export type IMenuItemActionScmChange = {
  __typename?: 'MenuItemActionScmChange';
  title?: Maybe<Array<Maybe<IMenuItemAction>>>;
};

export type IMenuItemActionView = {
  __typename?: 'MenuItemActionView';
  /**  The contributed view title menu  */
  title?: Maybe<Array<Maybe<IMenuItemAction>>>;
  /**  The contributed view item context menu  */
  item?: Maybe<IMenuItemActionContext>;
};

export type IMenuItemInput = {
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  enabled?: Maybe<Scalars['Boolean']>;
  run?: Maybe<IActionRunInput>;
};

export type IMenus = {
  __typename?: 'Menus';
  /**  The Command Palette  */
  commandPalette?: Maybe<Array<Maybe<IMenuItemAction>>>;
  /**  The file explorer  */
  explorer?: Maybe<IMenuItemActionContext>;
  /**  The editor  */
  editor?: Maybe<IMenuItemActionEditor>;
  /**  The debug  */
  debug?: Maybe<IMenuItemActionDebug>;
  /**  The Source Control  */
  scm?: Maybe<IMenuItemActionScm>;
  /**  The contributed view  */
  view?: Maybe<IMenuItemActionView>;
  /**  The touch bar (macOS only)  */
  touchBar?: Maybe<Array<Maybe<IMenuItemAction>>>;
};

export { MergeGroupMode };

export type IMergeGroupOptions_Input = {
  mode?: Maybe<MergeGroupMode>;
  index?: Maybe<Scalars['Int']>;
};

export type IMessageBoxOptions = {
  __typename?: 'MessageBoxOptions';
  type?: Maybe<Scalars['String']>;
  buttons?: Maybe<Array<Maybe<Scalars['String']>>>;
  defaultId?: Maybe<Scalars['Int']>;
  title?: Maybe<Scalars['String']>;
  message?: Maybe<Scalars['String']>;
  detail?: Maybe<Scalars['String']>;
  checkboxLabel?: Maybe<Scalars['String']>;
  checkboxChecked?: Maybe<Scalars['Boolean']>;
  cancelId?: Maybe<Scalars['Int']>;
  noLink?: Maybe<Scalars['Boolean']>;
  normalizeAccessKeys?: Maybe<Scalars['Boolean']>;
};

export type IMessageBoxResult = {
  __typename?: 'MessageBoxResult';
  button?: Maybe<Scalars['Int']>;
  checkboxChecked?: Maybe<Scalars['Boolean']>;
};

export type IMessageLink = {
  __typename?: 'MessageLink';
  name?: Maybe<Scalars['String']>;
  href?: Maybe<Scalars['String']>;
  offset?: Maybe<Scalars['Int']>;
  length?: Maybe<Scalars['Int']>;
};

export type IMessageLinkInput = {
  name?: Maybe<Scalars['String']>;
  href?: Maybe<Scalars['String']>;
  offset?: Maybe<Scalars['Int']>;
  length?: Maybe<Scalars['Int']>;
};

export type IModelLoadOrCreateOptions_Input = {
  /**  Context why the model is being loaded or created. */
  reason?: Maybe<IFileLoadReason>;
  /**  The language mode to use for the model text content. */
  mode?: Maybe<Scalars['String']>;
  /**  The encoding to use when resolving the model text content. */
  encoding?: Maybe<Scalars['String']>;
  /**
   * If the model was already loaded before, allows to trigger
   * a reload of it to fetch the latest contents:
   * - async: loadOrCreate() will return immediately and trigger
   * a reload that will run in the background.
   * - sync: loadOrCreate() will only return resolved when the
   * model was finished reloading.
   */
  reload?: Maybe<IModelLoadOrCreateOptions_Input_Reload>;
  /**  Allow to load a model even if we think it is a binary file. */
  allowBinary?: Maybe<Scalars['Boolean']>;
};

export type IModelLoadOrCreateOptions_Input_Reload = {
  async?: Maybe<Scalars['Boolean']>;
};

/**  All Moleculer Topic names are extended from this. */
export const enum IMoleculerServiceName {
  ConfigurationClientService = 'ConfigurationClientService',
  ConfigurationService = 'ConfigurationService',
  EnvironmentService = 'EnvironmentService',
  LifecycleService = 'LifecycleService',
  WorkbenchLifecycleEmitter = 'WorkbenchLifecycleEmitter',
  WorkbenchLifecycleListener = 'WorkbenchLifecycleListener',
  WorkspaceClientContextService = 'WorkspaceClientContextService',
  WorkspaceContextService = 'WorkspaceContextService',
  WorkspaceEventually = 'WorkspaceEventually',
  /**  Following services will help to wait other services  */
  WorkspaceReady = 'WorkspaceReady',
  WorkspaceRestore = 'WorkspaceRestore',
  WorkspaceStarted = 'WorkspaceStarted',
  Dummy = 'dummy'
};

export type IMoveEditorOptions_Input = {
  index?: Maybe<Scalars['Int']>;
  inactive?: Maybe<Scalars['Boolean']>;
  preserveFocus?: Maybe<Scalars['Boolean']>;
};

export type IMoveEditor_Input = {
  resource: Scalars['String'];
  editorId?: Maybe<Scalars['Int']>;
  name?: Maybe<Scalars['String']>;
};

export type IMutation = {
  __typename?: 'Mutation';
  activate?: Maybe<Scalars['Boolean']>;
  activateEditor?: Maybe<Scalars['Boolean']>;
  addEntry?: Maybe<Scalars['Boolean']>;
  addFolders?: Maybe<Scalars['Boolean']>;
  addNotification?: Maybe<Scalars['Boolean']>;
  canHandleResource?: Maybe<Scalars['Boolean']>;
  changeEdit?: Maybe<Scalars['Boolean']>;
  changeKeybinding?: Maybe<Scalars['Boolean']>;
  changeWhenExpression?: Maybe<Scalars['Boolean']>;
  changeWorkspace?: Maybe<Scalars['Boolean']>;
  clearSearchCache?: Maybe<Scalars['Boolean']>;
  closeAllEditors?: Maybe<Scalars['Boolean']>;
  closeDialog?: Maybe<Scalars['Boolean']>;
  closeEditor?: Maybe<Scalars['Boolean']>;
  closeEditors?: Maybe<Scalars['Boolean']>;
  closeNotification?: Maybe<Scalars['Boolean']>;
  codeLenseProviderDefinition?: Maybe<Scalars['Observable']>;
  completionProviderDefinition?: Maybe<Scalars['Observable']>;
  copy?: Maybe<Scalars['Boolean']>;
  copyFile?: Maybe<IFileStatWithMetadata>;
  /**  Create a new extension in the extension registry. */
  createExtension: IRegistryExtension;
  createFile?: Maybe<IFileStatWithMetadata>;
  createFolder?: Maybe<IFileStatWithMetadata>;
  /**
   * Create a file. If the file exists it will be overwritten with the contents if
   * the options enable to overwrite.
   */
  createTextFile?: Maybe<IFileStatWithMetadata>;
  createUntitledFile?: Maybe<IFileStatWithMetadata>;
  definitionDefinition?: Maybe<Scalars['Observable']>;
  del?: Maybe<Scalars['Boolean']>;
  /**
   * Delete an extension from the extension registry.
   *
   * Only authorized extension publishers may perform this mutation.
   */
  deleteExtension: IEmptyResponse;
  /** Delete a file. If the file is dirty, it will get reverted and then deleted from disk. */
  deleteTextFile?: Maybe<Scalars['Boolean']>;
  documentFormattingProviderDefinition?: Maybe<Scalars['Observable']>;
  documentHighLightProviderDefinition?: Maybe<Scalars['Observable']>;
  documentSymbolDefinition?: Maybe<Scalars['Observable']>;
  dummy?: Maybe<Scalars['Int']>;
  editKeybinding?: Maybe<Scalars['Boolean']>;
  findFileStat?: Maybe<IFileStatWithMetadata>;
  getConfigurationTarget?: Maybe<Scalars['Int']>;
  getEditorState?: Maybe<ICodeEditorViewState>;
  getFilesTreeData?: Maybe<Array<Maybe<IFileStatWithMetadata>>>;
  gotoLine?: Maybe<Scalars['Boolean']>;
  handler?: Maybe<Scalars['Boolean']>;
  hideContextMenu?: Maybe<Scalars['Boolean']>;
  hideInputModel?: Maybe<Scalars['Boolean']>;
  hideKeybindingDialog?: Maybe<Scalars['Boolean']>;
  highlightLine?: Maybe<Scalars['Boolean']>;
  hoverProviderDefinition?: Maybe<Scalars['Observable']>;
  install?: Maybe<IExtensionIdentifier>;
  jsonWrite?: Maybe<Scalars['Boolean']>;
  keepOpen?: Maybe<Scalars['Boolean']>;
  loadFile?: Maybe<IFileStatWithMetadata>;
  loadFileContent?: Maybe<IFileContent>;
  loadFileWithContent?: Maybe<ITextFileContent>;
  loadFilesTreeData?: Maybe<Array<Maybe<IFileStatWithMetadata>>>;
  lookupKeybinding?: Maybe<Scalars['String']>;
  makePinEditor?: Maybe<Scalars['Boolean']>;
  moveEditorInsideGroup?: Maybe<Scalars['Boolean']>;
  moveFile?: Maybe<IFileStatWithMetadata>;
  /** Move a file. If the file is dirty, its contents will be preserved and restored. */
  moveTextFile?: Maybe<IFileStatWithMetadata>;
  notify?: Maybe<Scalars['Boolean']>;
  notifyError?: Maybe<Scalars['Boolean']>;
  notifyInfo?: Maybe<Scalars['Boolean']>;
  notifyPrompt?: Maybe<Scalars['Boolean']>;
  notifyWarn?: Maybe<Scalars['Boolean']>;
  /**
   * Open an editor or file in an EditorGroup.
   * If no EditorGroup exist, it creates one.
   */
  openEditor?: Maybe<Scalars['Boolean']>;
  /**
   * Open an editor in an editor group.
   *
   * @param editor the editor to open
   * @param group the target group. If unspecified, the editor will open in the currently
   * active group. Use `SIDE_GROUP_TYPE` to open the editor in a new editor group to the side
   * of the currently active group.
   */
  openEditorWithResourceDiffInput?: Maybe<Scalars['Boolean']>;
  /**
   * Open an editor in an editor group.
   *
   * @param editor the editor to open
   * @param group the target group. If unspecified, the editor will open in the currently
   * active group. Use `SIDE_GROUP_TYPE` to open the editor in a new editor group to the side
   * of the currently active group.
   */
  openEditorWithResourceInput?: Maybe<Scalars['Boolean']>;
  /**
   * Open an editor in an editor group.
   *
   * @param editor the editor to open
   * @param group the target group. If unspecified, the editor will open in the currently
   * active group. Use `SIDE_GROUP_TYPE` to open the editor in a new editor group to the side
   * of the currently active group.
   */
  openEditorWithResourceSideBySideInput?: Maybe<Scalars['Boolean']>;
  /**
   * Open an editor in an editor group.
   *
   * @param editor the editor to open
   * @param group the target group. If unspecified, the editor will open in the currently
   * active group. Use `SIDE_GROUP_TYPE` to open the editor in a new editor group to the side
   * of the currently active group.
   */
  openEditorWithUntitledResourceInput?: Maybe<Scalars['Boolean']>;
  /** @deprecated use openEditor */
  openFile?: Maybe<Scalars['Boolean']>;
  openGlobalKeybindingSettings?: Maybe<Scalars['Boolean']>;
  openLanguageDocument?: Maybe<Scalars['Observable']>;
  openPreferenceSettings?: Maybe<Scalars['Boolean']>;
  /**
   * Publish an extension in the extension registry, creating it (if it doesn't yet exist) or updating it (if it
   * does).
   *
   * This is a helper that wraps multiple other GraphQL mutations to expose a single API for publishing an
   * extension.
   */
  publishExtension: IExtensionRegistryPublishExtensionResult;
  /**
   * Read the contents of a file identified by the resource.
   * Added inaddition to the query as we want to manipulate the cache with `update` option available in `mutation`.
   * However, with apollo-client v3.0 we can start using it as `Query` as they support custom `merge`.
   */
  readTextFile?: Maybe<ITextFileContent>;
  referenceProviderDefinition?: Maybe<Scalars['Observable']>;
  registerKeybinding?: Maybe<Scalars['Boolean']>;
  removeChangedContent?: Maybe<Scalars['Boolean']>;
  removeEdit?: Maybe<Scalars['Boolean']>;
  removeExtension?: Maybe<Scalars['Boolean']>;
  removeFolders?: Maybe<Scalars['Boolean']>;
  removeKeybinding?: Maybe<Scalars['Boolean']>;
  removeStatusbarEntry?: Maybe<Scalars['Boolean']>;
  rename?: Maybe<IFileStatWithMetadata>;
  renameDefinition?: Maybe<Scalars['Observable']>;
  replaceContent?: Maybe<IReplaceContentResult>;
  resetKeybinding?: Maybe<Scalars['Boolean']>;
  resetSetting?: Maybe<Scalars['Boolean']>;
  resolveKeyboardEvent?: Maybe<IKeyboardEvent_Output>;
  runMenuAction?: Maybe<Scalars['Boolean']>;
  saveAllEditor?: Maybe<Scalars['Boolean']>;
  saveFile?: Maybe<IFileStat>;
  saveFileAs?: Maybe<Scalars['URI']>;
  saveUserSettings?: Maybe<ISaveWorkspaceRes>;
  saveWorkspaceSettings?: Maybe<ISaveWorkspaceRes>;
  searchKeybinding?: Maybe<Scalars['Boolean']>;
  selectEdit?: Maybe<Scalars['Boolean']>;
  setEncoding?: Maybe<Scalars['Boolean']>;
  setFilesTreeData?: Maybe<Scalars['Boolean']>;
  setSelected?: Maybe<Scalars['Boolean']>;
  setSelectedKeybindingIndex?: Maybe<Scalars['Boolean']>;
  setStatusMessage?: Maybe<Scalars['String']>;
  show?: Maybe<Scalars['Boolean']>;
  showContextMenu?: Maybe<Scalars['Boolean']>;
  showInput?: Maybe<Scalars['Boolean']>;
  showPickInput?: Maybe<Scalars['Boolean']>;
  startExtensionHost?: Maybe<Scalars['Boolean']>;
  stopEditWhenExpression?: Maybe<Scalars['Boolean']>;
  switchSettings?: Maybe<Scalars['Boolean']>;
  testNotification?: Maybe<Scalars['Boolean']>;
  textSearch_?: Maybe<ISearchComplete>;
  unwatch?: Maybe<Scalars['Boolean']>;
  unwatchFileChanges?: Maybe<Scalars['Boolean']>;
  updateChangedContent?: Maybe<Scalars['Boolean']>;
  updateConfigurationValue?: Maybe<Scalars['Boolean']>;
  updateContent?: Maybe<IFileStatWithMetadata>;
  updateContext?: Maybe<Scalars['Boolean']>;
  updateEditorState?: Maybe<Scalars['Boolean']>;
  /**
   * Update an extension in the extension registry.
   *
   * Only authorized extension publishers may perform this mutation.
   */
  updateExtension: IRegistryExtension;
  updateFileDirtyState?: Maybe<Scalars['Boolean']>;
  updateFolders?: Maybe<Scalars['Boolean']>;
  updateLayout?: Maybe<Scalars['Boolean']>;
  /** @deprecated need to remove */
  updateModel?: Maybe<Scalars['Boolean']>;
  updateSelectedResource?: Maybe<Scalars['Boolean']>;
  updateStatusbarEntry?: Maybe<Scalars['Boolean']>;
  updateWorkspaceContextAddFolders?: Maybe<Array<Maybe<IWorkspaceFolderData>>>;
  updateWorkspaceContextRemoveFolders?: Maybe<Array<Maybe<IWorkspaceFolderData>>>;
  updateWorkspaceContextUpdateFolders?: Maybe<Array<Maybe<IWorkspaceFolderData>>>;
  watchFile?: Maybe<Scalars['String']>;
  /**
   * Allows to start a watcher that reports file change events on the provided resource.
   *
   * Note: watching a folder does not report events recursively for child folders yet.
   */
  watchFileChanges?: Maybe<Scalars['Boolean']>;
  writeChunk?: Maybe<IUpdatedResource>;
  writeChunkWithDelay?: Maybe<IUpdateDelayedResource>;
  writeContent?: Maybe<Scalars['Boolean']>;
  /** Update a file with given contents. */
  writeTextFile?: Maybe<IFileStatWithMetadata>;
};


export type IMutationActivateArgs = {
  request: IIActivationRequest;
};


export type IMutationActivateEditorArgs = {
  editorId?: Maybe<Scalars['Int']>;
};


export type IMutationAddEntryArgs = {
  arg?: Maybe<IAddEntryInput>;
};


export type IMutationAddFoldersArgs = {
  folders?: Maybe<Array<Maybe<IFolderInput>>>;
  index?: Maybe<Scalars['Int']>;
};


export type IMutationAddNotificationArgs = {
  notification?: Maybe<INotificationInput>;
};


export type IMutationCanHandleResourceArgs = {
  resource: Scalars['URI'];
};


export type IMutationChangeEditArgs = {
  changed?: Maybe<Scalars['Boolean']>;
  resource?: Maybe<Scalars['String']>;
};


export type IMutationChangeKeybindingArgs = {
  editItem?: Maybe<IKeybindingItemInput>;
  selectedIndex?: Maybe<Scalars['Int']>;
  isOpenDialog?: Maybe<Scalars['Boolean']>;
};


export type IMutationChangeWhenExpressionArgs = {
  editItem?: Maybe<IKeybindingItemInput>;
  editWhenIndex?: Maybe<Scalars['Int']>;
  newWhen?: Maybe<Scalars['String']>;
};


export type IMutationChangeWorkspaceArgs = {
  args?: Maybe<IArgsInput>;
};


export type IMutationClearSearchCacheArgs = {
  cacheKey?: Maybe<Scalars['String']>;
};


export type IMutationCloseEditorArgs = {
  content?: Maybe<ICloseEditor_Input>;
  layoutId?: Maybe<Scalars['String']>;
};


export type IMutationCloseEditorsArgs = {
  editors?: Maybe<Array<Maybe<ICloseEditor_Input>>>;
  editorGroupId?: Maybe<Scalars['Int']>;
  options?: Maybe<ICloseEditorOptions_Input>;
};


export type IMutationCloseNotificationArgs = {
  index?: Maybe<Scalars['Int']>;
};


export type IMutationCodeLenseProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationCompletionProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationCopyArgs = {
  value?: Maybe<Scalars['String']>;
};


export type IMutationCopyFileArgs = {
  source: Scalars['URI'];
  target: Scalars['URI'];
  overwrite?: Maybe<Scalars['Boolean']>;
};


export type IMutationCreateExtensionArgs = {
  publisher: Scalars['ID'];
  name: Scalars['String'];
};


export type IMutationCreateFileArgs = {
  resource: Scalars['URI'];
  bufferOrReadable?: Maybe<Scalars['VSBuffer']>;
  options?: Maybe<ICreateFileOptions_Input>;
};


export type IMutationCreateFolderArgs = {
  resource: Scalars['URI'];
};


export type IMutationCreateTextFileArgs = {
  resource: Scalars['URI'];
  content?: Maybe<Scalars['String']>;
  overwrite?: Maybe<Scalars['Boolean']>;
};


export type IMutationCreateUntitledFileArgs = {
  resource?: Maybe<Scalars['URI']>;
  mode?: Maybe<Scalars['String']>;
  initialValue?: Maybe<Scalars['String']>;
  encoding?: Maybe<Scalars['String']>;
  hasAssociatedFilePath?: Maybe<Scalars['Boolean']>;
};


export type IMutationDefinitionDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationDelArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IDeleteFileOptions_Input>;
};


export type IMutationDeleteExtensionArgs = {
  extension: Scalars['ID'];
};


export type IMutationDeleteTextFileArgs = {
  resource: Scalars['URI'];
  useTrash?: Maybe<Scalars['Boolean']>;
};


export type IMutationDocumentFormattingProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationDocumentHighLightProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationDocumentSymbolDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationEditKeybindingArgs = {
  keybindingItem?: Maybe<IKeybindingItemInput>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
};


export type IMutationFindFileStatArgs = {
  resource: Scalars['URI'];
};


export type IMutationGetConfigurationTargetArgs = {
  resource?: Maybe<Scalars['URI']>;
};


export type IMutationGetEditorStateArgs = {
  editorId: Scalars['String'];
  resource: Scalars['URI'];
};


export type IMutationGetFilesTreeDataArgs = {
  resource: Scalars['URI'];
};


export type IMutationGotoLineArgs = {
  range?: Maybe<ILineRangeInput>;
};


export type IMutationHandlerArgs = {
  arg?: Maybe<IActionRunInput>;
};


export type IMutationHighlightLineArgs = {
  range?: Maybe<ILineRangeInput>;
};


export type IMutationHoverProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationInstallArgs = {
  vsix: Scalars['String'];
};


export type IMutationJsonWriteArgs = {
  resource?: Maybe<Scalars['URI']>;
  value?: Maybe<IIjsonValueInput>;
  save?: Maybe<Scalars['Boolean']>;
};


export type IMutationKeepOpenArgs = {
  content?: Maybe<IKeepOpen_Input>;
};


export type IMutationLoadFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IResolveMetadataFileOptions_Input>;
};


export type IMutationLoadFileContentArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadFileOptions_Input>;
};


export type IMutationLoadFileWithContentArgs = {
  resource: Scalars['URI'];
  options?: Maybe<ILoadOptions_Input>;
};


export type IMutationLoadFilesTreeDataArgs = {
  resource: Scalars['URI'];
};


export type IMutationLookupKeybindingArgs = {
  commandId?: Maybe<Scalars['String']>;
};


export type IMutationMakePinEditorArgs = {
  tabId?: Maybe<Scalars['String']>;
  editorId?: Maybe<Scalars['Int']>;
};


export type IMutationMoveEditorInsideGroupArgs = {
  content?: Maybe<IMoveEditor_Input>;
  moveOptions?: Maybe<IMoveEditorOptions_Input>;
};


export type IMutationMoveFileArgs = {
  source: Scalars['URI'];
  target: Scalars['URI'];
  overwrite?: Maybe<Scalars['Boolean']>;
};


export type IMutationMoveTextFileArgs = {
  source: Scalars['URI'];
  target: Scalars['URI'];
  overwrite?: Maybe<Scalars['Boolean']>;
};


export type IMutationNotifyArgs = {
  notification?: Maybe<INotificationInput>;
};


export type IMutationNotifyErrorArgs = {
  message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
};


export type IMutationNotifyInfoArgs = {
  message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
};


export type IMutationNotifyPromptArgs = {
  severity?: Maybe<NotificationSeverity>;
  message?: Maybe<Scalars['String']>;
  choices?: Maybe<Array<Maybe<IPromptChoiceInput>>>;
  options?: Maybe<IPromptOptionsInput>;
};


export type IMutationNotifyWarnArgs = {
  message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
};


export type IMutationOpenEditorArgs = {
  content: IOpenEditor_Input;
  options?: Maybe<IEditorOpenOptions_Input>;
};


export type IMutationOpenEditorWithResourceDiffInputArgs = {
  editor: IResourceDiff_Input;
  group?: Maybe<Scalars['Int']>;
};


export type IMutationOpenEditorWithResourceInputArgs = {
  editor: IResource_Input;
  group?: Maybe<Scalars['Int']>;
};


export type IMutationOpenEditorWithResourceSideBySideInputArgs = {
  editor: IResourceSideBySide_Input;
  group?: Maybe<Scalars['Int']>;
};


export type IMutationOpenEditorWithUntitledResourceInputArgs = {
  editor: IUntitledResource_Input;
  group?: Maybe<Scalars['Int']>;
};


export type IMutationOpenFileArgs = {
  content: IOpenEditor_Input;
  options?: Maybe<IEditorOpenOptions_Input>;
};


export type IMutationOpenGlobalKeybindingSettingsArgs = {
  textual?: Maybe<Scalars['Boolean']>;
};


export type IMutationOpenLanguageDocumentArgs = {
  params?: Maybe<IOpenDocumentParamsInput>;
};


export type IMutationOpenPreferenceSettingsArgs = {
  jsonEditor?: Maybe<Scalars['Boolean']>;
  query?: Maybe<Scalars['String']>;
};


export type IMutationPublishExtensionArgs = {
  name?: Maybe<Scalars['String']>;
  version?: Maybe<Scalars['String']>;
  extensionID: Scalars['String'];
  manifest: Scalars['String'];
  bundle?: Maybe<Scalars['String']>;
  sourceMap?: Maybe<Scalars['String']>;
  force?: Maybe<Scalars['Boolean']>;
};


export type IMutationReadTextFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadTextFileOptions_Input>;
};


export type IMutationReferenceProviderDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationRegisterKeybindingArgs = {
  keybinding?: Maybe<IKeybindingInput>;
};


export type IMutationRemoveChangedContentArgs = {
  resource: Scalars['URI'];
  reset?: Maybe<Scalars['Boolean']>;
};


export type IMutationRemoveEditArgs = {
  content?: Maybe<IRemoveEditor_Input>;
};


export type IMutationRemoveExtensionArgs = {
  id: Scalars['String'];
};


export type IMutationRemoveFoldersArgs = {
  folders?: Maybe<Array<Maybe<Scalars['URI']>>>;
};


export type IMutationRemoveKeybindingArgs = {
  keybindingItem?: Maybe<IKeybindingItemInput>;
};


export type IMutationRemoveStatusbarEntryArgs = {
  id: Scalars['ID'];
};


export type IMutationRenameArgs = {
  resource: Scalars['URI'];
  target: Scalars['URI'];
  overwrite?: Maybe<Scalars['Boolean']>;
};


export type IMutationRenameDefinitionArgs = {
  params?: Maybe<ITextDocumentPositionParamsInput>;
};


export type IMutationReplaceContentArgs = {
  resource?: Maybe<Scalars['String']>;
  oldText?: Maybe<Scalars['String']>;
  newText?: Maybe<Scalars['String']>;
};


export type IMutationResetKeybindingArgs = {
  keybindingItem?: Maybe<IKeybindingItemInput>;
};


export type IMutationResetSettingArgs = {
  resource?: Maybe<Scalars['URI']>;
  settingKey?: Maybe<Scalars['String']>;
};


export type IMutationResolveKeyboardEventArgs = {
  keyboardEvent?: Maybe<IKeyboardEventInput>;
};


export type IMutationRunMenuActionArgs = {
  argument?: Maybe<IActionRunInput>;
};


export type IMutationSaveAllEditorArgs = {
  allSave?: Maybe<Scalars['Boolean']>;
};


export type IMutationSaveFileArgs = {
  resource: Scalars['URI'];
  versionId?: Maybe<Scalars['Int']>;
  options: ISaveOptions_Input;
};


export type IMutationSaveFileAsArgs = {
  resource: Scalars['String'];
  versionId?: Maybe<Scalars['Int']>;
  options: ISaveOptions_Input;
  target?: Maybe<Scalars['String']>;
};


export type IMutationSaveUserSettingsArgs = {
  content?: Maybe<Scalars['String']>;
};


export type IMutationSearchKeybindingArgs = {
  value?: Maybe<Scalars['String']>;
};


export type IMutationSelectEditArgs = {
  content?: Maybe<ISelectEditor_Input>;
};


export type IMutationSetEncodingArgs = {
  resource: Scalars['URI'];
  encoding?: Maybe<Scalars['String']>;
};


export type IMutationSetFilesTreeDataArgs = {
  treeData?: Maybe<Array<Maybe<ITreeData_Input>>>;
  originalData?: Maybe<ITreeData_Input>;
};


export type IMutationSetSelectedArgs = {
  selectedValue?: Maybe<Array<Maybe<IPickItem>>>;
  inputValue?: Maybe<Scalars['String']>;
};


export type IMutationSetSelectedKeybindingIndexArgs = {
  index?: Maybe<Scalars['Int']>;
};


export type IMutationSetStatusMessageArgs = {
  arg?: Maybe<ISetStatusMsgInput>;
};


export type IMutationShowArgs = {
  dialog?: Maybe<IDialogInput>;
};


export type IMutationShowContextMenuArgs = {
  delegate?: Maybe<IContextMenuInput>;
};


export type IMutationShowInputArgs = {
  options?: Maybe<IInputOptions>;
};


export type IMutationShowPickInputArgs = {
  items?: Maybe<Array<Maybe<IPickItem>>>;
  options?: Maybe<IPickInputOptions>;
};


export type IMutationStartExtensionHostArgs = {
  request?: Maybe<Scalars['String']>;
};


export type IMutationSwitchSettingsArgs = {
  target?: Maybe<Scalars['Int']>;
  editorId?: Maybe<Scalars['Int']>;
  resource?: Maybe<Scalars['URI']>;
  jsonEditor?: Maybe<Scalars['Boolean']>;
};


export type IMutationTextSearch_Args = {
  query?: Maybe<ITextQueryInput>;
};


export type IMutationUnwatchArgs = {
  resource: Scalars['URI'];
  session: Scalars['String'];
};


export type IMutationUnwatchFileChangesArgs = {
  resource: Scalars['URI'];
  session: Scalars['String'];
};


export type IMutationUpdateChangedContentArgs = {
  resource: Scalars['URI'];
  changedEvent: IContentChangedEvent_Input;
};


export type IMutationUpdateConfigurationValueArgs = {
  key: Scalars['String'];
  value: Scalars['AnyObject'];
  overrides?: Maybe<IConfigurationOverrides_Input>;
  target?: Maybe<Scalars['Int']>;
  donotNotifyError?: Maybe<Scalars['Boolean']>;
};


export type IMutationUpdateContentArgs = {
  resource: Scalars['URI'];
  value: Scalars['VSBuffer'];
  options: IWriteFileOptions_Input;
};


export type IMutationUpdateContextArgs = {
  key?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['AnyObject']>;
};


export type IMutationUpdateEditorStateArgs = {
  editorId: Scalars['String'];
  resource: Scalars['URI'];
  state: ICodeEditorViewState_Input;
};


export type IMutationUpdateExtensionArgs = {
  extension: Scalars['ID'];
  name?: Maybe<Scalars['String']>;
};


export type IMutationUpdateFileDirtyStateArgs = {
  resource: Scalars['URI'];
  isFileDirty: Scalars['Boolean'];
};


export type IMutationUpdateFoldersArgs = {
  foldersToAdd?: Maybe<Array<Maybe<IFolderInput>>>;
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>>>;
  index?: Maybe<Scalars['Int']>;
};


export type IMutationUpdateLayoutArgs = {
  changedLayout?: Maybe<IEditorLayout_Input>;
};


export type IMutationUpdateModelArgs = {
  model?: Maybe<IIModelInput>;
};


export type IMutationUpdateSelectedResourceArgs = {
  resource: Scalars['URI'];
};


export type IMutationUpdateStatusbarEntryArgs = {
  arg?: Maybe<IUpdateEntryInput>;
};


export type IMutationUpdateWorkspaceContextAddFoldersArgs = {
  foldersToAdd?: Maybe<Array<Maybe<IFoldersToAdd_Input>>>;
  index?: Maybe<Scalars['Int']>;
};


export type IMutationUpdateWorkspaceContextRemoveFoldersArgs = {
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>>>;
};


export type IMutationUpdateWorkspaceContextUpdateFoldersArgs = {
  foldersToAdd?: Maybe<Array<Maybe<IFoldersToAdd_Input>>>;
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>>>;
  index?: Maybe<Scalars['Int']>;
};


export type IMutationWatchFileArgs = {
  resource: Scalars['URI'];
};


export type IMutationWatchFileChangesArgs = {
  resource: Scalars['URI'];
  options: IWatchOptions_Input;
};


export type IMutationWriteChunkArgs = {
  resource: Scalars['URI'];
  changes: Array<Maybe<IChangesChunk_Input>>;
  options: IWriteTextFileOptions_Input;
};


export type IMutationWriteChunkWithDelayArgs = {
  resource: Scalars['URI'];
  changes: Array<Maybe<IChangesChunk_Input>>;
  options: IWriteTextFileOptions_Input;
};


export type IMutationWriteTextFileArgs = {
  resource: Scalars['URI'];
  value: Scalars['String'];
  options: IWriteTextFileOptions_Input;
};

export type INativeOpenDialogOptions = {
  __typename?: 'NativeOpenDialogOptions';
  windowId?: Maybe<Scalars['Int']>;
  forceNewWindow?: Maybe<Scalars['Boolean']>;
  defaultPath?: Maybe<Scalars['String']>;
  telemetryEventName?: Maybe<Scalars['String']>;
};

export type INewWindowOptions = {
  __typename?: 'NewWindowOptions';
  remoteAuthority?: Maybe<Scalars['String']>;
  reuseWindow?: Maybe<Scalars['Boolean']>;
};

/** An object with an ID. */
export type INode = {
  /** The ID of the node. */
  id: Scalars['ID'];
};

export type INotification = {
  __typename?: 'Notification';
  index?: Maybe<Scalars['Boolean']>;
  /** The severity of the notification. Either `Info`, `Warning` or `Error`. */
  severity?: Maybe<NotificationSeverity>;
  /**
   * The message of the notification. This can either be a `string` or `Error`. Messages
   * can optionally include links in the format: `[text](link)`
   */
  message?: Maybe<Scalars['String']>;
  /** The source of the notification appears as additional information. */
  source?: Maybe<Scalars['String']>;
  /**
   * Actions to show as part of the notification. Primary actions show up as
   * buttons as part of the message and will clost the notification once clicked.
   *
   * Secondary actions are meant to provide additional configuration or context
   * for the notification and will show up less prominent. A notification does not
   * close automatically when invoking a secondary action.
   *
   * **Note:** If you intent is to show a message with actions to the user, consider
   * the `INotificationService.prompt()` method instead which are optimized for
   * this usecase and much easier to use!
   */
  actions?: Maybe<INotificationActions>;
  /**
   * Sticky notifications are not automatically removed after a certain timeout. By
   * default, notifications with primary actions and severity error are always sticky.
   */
  sticky?: Maybe<Scalars['Boolean']>;
};

export type INotificationActions = {
  __typename?: 'NotificationActions';
  /**
   * Primary actions show up as buttons as part of the message and will close
   * the notification once clicked.
   */
  primary?: Maybe<Array<Maybe<IAction>>>;
  /**
   * Secondary actions are meant to provide additional configuration or context
   * for the notification and will show up less prominent. A notification does not
   * close automatically when invoking a secondary action.
   */
  secondary?: Maybe<Array<Maybe<IAction>>>;
};

export type INotificationActionsInput = {
  primary?: Maybe<Array<Maybe<IActionInput>>>;
  secondary?: Maybe<Array<Maybe<IActionInput>>>;
};

export type INotificationChangeEvent = {
  __typename?: 'NotificationChangeEvent';
  /** The index this notification has in the list of notifications. */
  index?: Maybe<Scalars['Int']>;
  /** The notification this change is about. */
  item?: Maybe<INotificationViewItem>;
  /** The kind of notification change. */
  kind?: Maybe<INotificationChangeType>;
};

export const enum INotificationChangeType {
  Add = 'ADD',
  Change = 'CHANGE',
  Remove = 'REMOVE'
};

export type INotificationInput = {
  severity?: Maybe<NotificationSeverity>;
  message?: Maybe<INotificationMessageInput>;
  source?: Maybe<Scalars['String']>;
  actions?: Maybe<INotificationActionsInput>;
  sticky?: Maybe<Scalars['Boolean']>;
};

export type INotificationMessage = {
  __typename?: 'NotificationMessage';
  raw?: Maybe<Scalars['String']>;
  original?: Maybe<INotificationMessage>;
  value?: Maybe<Scalars['String']>;
  links?: Maybe<Array<Maybe<IMessageLink>>>;
};

export type INotificationMessageInput = {
  raw?: Maybe<Scalars['String']>;
  original?: Maybe<INotificationMessageInput>;
  value?: Maybe<Scalars['String']>;
  links?: Maybe<Array<Maybe<IMessageLinkInput>>>;
};

export { NotificationSeverity };

export type INotificationViewItem = {
  __typename?: 'NotificationViewItem';
  severity?: Maybe<NotificationSeverity>;
  sticky?: Maybe<Scalars['Boolean']>;
  silent?: Maybe<Scalars['Boolean']>;
  message?: Maybe<INotificationMessage>;
  source?: Maybe<Scalars['String']>;
  action?: Maybe<INotificationActions>;
  progress?: Maybe<INotificationViewItemProgress>;
  expanded?: Maybe<Scalars['Boolean']>;
  canCollapse?: Maybe<Scalars['Boolean']>;
};

export const enum INotificationViewItemLabelKind {
  Severity = 'SEVERITY',
  Message = 'MESSAGE',
  Actions = 'ACTIONS',
  Progress = 'PROGRESS'
};

export type INotificationViewItemProgress = {
  __typename?: 'NotificationViewItemProgress';
  state?: Maybe<INotificationViewItemProgressState>;
};

export type INotificationViewItemProgressState = {
  __typename?: 'NotificationViewItemProgressState';
  /** Causes the progress bar to spin infinitely. */
  infinite?: Maybe<Scalars['Boolean']>;
  /** Indicate the total amount of work. */
  total?: Maybe<Scalars['Int']>;
  /** Indicate that a specific chunk of work is done. */
  worked?: Maybe<Scalars['Int']>;
  /** Indicate that the long running operation is done. */
  done?: Maybe<Scalars['Boolean']>;
};

export type INotifications = {
  __typename?: 'Notifications';
  notifications?: Maybe<Array<Maybe<INotification>>>;
};


/** One folder to search and a glob expression that should be applied. */
export type IOneSearchPathPattern = {
  __typename?: 'OneSearchPathPattern';
  searchPath?: Maybe<Scalars['URI']>;
  pattern?: Maybe<Scalars['String']>;
};

export type IOpenConfiguration = {
  __typename?: 'OpenConfiguration';
  context?: Maybe<IOpenContext>;
  contextWindowId?: Maybe<Scalars['Int']>;
  cli?: Maybe<Scalars['AnyObject']>;
  userEnv?: Maybe<Scalars['AnyObject']>;
  urisToOpen?: Maybe<Array<Maybe<IUriToOpen>>>;
  waitMarkerFileURI?: Maybe<Scalars['URI']>;
  preferNewWindow?: Maybe<Scalars['Boolean']>;
  forceNewWindow?: Maybe<Scalars['Boolean']>;
  forceNewTabbedWindow?: Maybe<Scalars['Boolean']>;
  forceReuseWindow?: Maybe<Scalars['Boolean']>;
  forceEmpty?: Maybe<Scalars['Boolean']>;
  diffMode?: Maybe<Scalars['Boolean']>;
  addMode?: Maybe<Scalars['Boolean']>;
  initialStartup?: Maybe<Scalars['Boolean']>;
  noRecentEntry?: Maybe<Scalars['Boolean']>;
};

export const enum IOpenContext {
  /** opening when running from the command line */
  Cli = 'CLI',
  /** macOS only: opening from the dock (also when opening files to a running instance from desktop) */
  Dock = 'DOCK',
  /** opening from the main application window */
  Menu = 'MENU',
  /** opening from a file or folder dialog */
  Dialog = 'DIALOG',
  /** opening from the OS's UI  */
  Desktop = 'DESKTOP',
  /** opening through the API */
  Api = 'API'
};

export type IOpenDialogOptions = {
  __typename?: 'OpenDialogOptions';
  title?: Maybe<Scalars['String']>;
  defaultPath?: Maybe<Scalars['String']>;
  buttonLabel?: Maybe<Scalars['String']>;
  filters?: Maybe<Array<Maybe<IFileFilter>>>;
  properties?: Maybe<Array<Maybe<IOpenDialogOptionsProperties>>>;
  message?: Maybe<Scalars['String']>;
};

export const enum IOpenDialogOptionsProperties {
  OpenFile = 'openFile',
  OpenDirectory = 'openDirectory',
  MultiSelections = 'multiSelections',
  ShowHiddenFiles = 'showHiddenFiles',
  CreateDirectory = 'createDirectory',
  PromptToCreate = 'promptToCreate',
  NoResolveAliases = 'noResolveAliases',
  TreatPackageAsDirectory = 'treatPackageAsDirectory'
};

export type IOpenDiff_Input = {
  resource?: Maybe<Scalars['String']>;
  editorId?: Maybe<Scalars['Int']>;
  name?: Maybe<Scalars['String']>;
};

export type IOpenDocumentParamsInput = {
  textDocument?: Maybe<IOpenDocumentTextParamsInput>;
};

export type IOpenDocumentTextParamsInput = {
  uri?: Maybe<Scalars['String']>;
  languageId?: Maybe<Scalars['String']>;
  version?: Maybe<Scalars['Int']>;
  text?: Maybe<Scalars['String']>;
};

export type IOpenEditor_Input = {
  resource: Scalars['String'];
  name: Scalars['String'];
  editorId?: Maybe<Scalars['Int']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  size?: Maybe<Scalars['Int']>;
  deleted?: Maybe<Scalars['Boolean']>;
};

export type IOpenFileRequest = {
  __typename?: 'OpenFileRequest';
  filesToOpenOrCreate?: Maybe<Array<Maybe<IIPathData>>>;
  filesToDiff?: Maybe<Array<Maybe<IIPathData>>>;
  filesToWait?: Maybe<IIPathsToWaitForData>;
  termProgram?: Maybe<Scalars['String']>;
};

export { OpenPositioningType };

export type IOpenSettings = {
  __typename?: 'OpenSettings';
  forceNewWindow?: Maybe<Scalars['Boolean']>;
  forceReuseWindow?: Maybe<Scalars['Boolean']>;
  diffMode?: Maybe<Scalars['Boolean']>;
  addMode?: Maybe<Scalars['Boolean']>;
  noRecentEntry?: Maybe<Scalars['Boolean']>;
  waitMarkerFileURI?: Maybe<Scalars['URI']>;
  args?: Maybe<Scalars['AnyObject']>;
};

export { OpenSideBySideDirection };

export type IOutput = {
  __typename?: 'Output';
  maxChannelHistory?: Maybe<Scalars['Int']>;
};

export type IOverrides = {
  __typename?: 'Overrides';
  contents?: Maybe<Scalars['AnyObject']>;
  identifiers?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IPageInfo = {
  __typename?: 'PageInfo';
  hasNextPage: Scalars['Boolean'];
};

export type IPath = IIPathData & {
  __typename?: 'Path';
  lineNumber?: Maybe<Scalars['Int']>;
  columnNumber?: Maybe<Scalars['Int']>;
  exists?: Maybe<Scalars['Boolean']>;
  /**  the file path to open within the instance  */
  fileUri?: Maybe<Scalars['URI']>;
};

export type IPathsToWaitFor = IIPathsToWaitForData & {
  __typename?: 'PathsToWaitFor';
  paths?: Maybe<Array<Maybe<IPath>>>;
  waitMarkerFileUri?: Maybe<Scalars['URI']>;
};

export type IPatternInfo = {
  __typename?: 'PatternInfo';
  pattern: Scalars['String'];
  isRegExp?: Maybe<Scalars['Boolean']>;
  isWordMatch?: Maybe<Scalars['Boolean']>;
  wordSeparators?: Maybe<Scalars['String']>;
  isMultiline?: Maybe<Scalars['Boolean']>;
  isCaseSensitive?: Maybe<Scalars['Boolean']>;
  isSmartCase?: Maybe<Scalars['Boolean']>;
};

export type IPatternInfoInput = {
  pattern: Scalars['String'];
  isRegExp?: Maybe<Scalars['Boolean']>;
  isWordMatch?: Maybe<Scalars['Boolean']>;
  wordSeparators?: Maybe<Scalars['String']>;
  isMultiline?: Maybe<Scalars['Boolean']>;
  isCaseSensitive?: Maybe<Scalars['Boolean']>;
  isSmartCase?: Maybe<Scalars['Boolean']>;
};

export type IPendingStatusbarEntry = {
  __typename?: 'PendingStatusbarEntry';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  priority?: Maybe<Scalars['Int']>;
};

export type IPickInputOptions = {
  title?: Maybe<Scalars['String']>;
  placeHolder?: Maybe<Scalars['String']>;
  matchOnDescription?: Maybe<Scalars['Boolean']>;
  matchOnDetail?: Maybe<Scalars['Boolean']>;
  matchOnLabel?: Maybe<Scalars['Boolean']>;
  canPickMany?: Maybe<Scalars['Boolean']>;
  activeItem?: Maybe<IPickItem>;
};

export type IPickItem = {
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  detail?: Maybe<Scalars['String']>;
  keybinding?: Maybe<IKeybindingItemInput>;
  italic?: Maybe<Scalars['Boolean']>;
  highlights?: Maybe<IQuickPickItemHighlightsInput>;
  picked?: Maybe<Scalars['Boolean']>;
  alwaysShow?: Maybe<Scalars['Boolean']>;
};

/**
 * @lsp - Position in a text document expressed as zero-based line and character offset.
 * The offsets are based on UTF-16 string representation. So a string of the form
 * `a𐐀b` the character offset of b is 3 since `𐐀` is represented using two code
 * untis in UTF-16.
 *
 * Positions are line end character agnostic. So you can not specify a position that
 * denotes `\r|\n` or `\n"` where `|` represents the character offset.
 *
 *
 * @editor - A position in the editor.
 */
export type IPosition = {
  __typename?: 'Position';
  /** @editor - line number (starts at 1) */
  lineNumber?: Maybe<Scalars['Int']>;
  /** @editor - column (the first character in a line is between column 1 and column 2) */
  column?: Maybe<Scalars['Int']>;
  /**
   * @lsp - Line position in a document (zero-based).
   * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
   * If a line number is negative, it defaults to 0.
   */
  line?: Maybe<Scalars['Int']>;
  /**
   * @lsp - Character offset on a line in a document (zer-based). Assuming that the line is represented as a string, the
   * `character` value represents the gap between the `character` and `character+1`.
   *
   * If the character value is greater than the line length it defaults back to the
   * line length.
   * If a line number is negative, it defaults to 0.
   */
  character?: Maybe<Scalars['Int']>;
};

export type IPositionInput = {
  line?: Maybe<Scalars['Int']>;
  character?: Maybe<Scalars['Int']>;
  lineNumber?: Maybe<Scalars['Int']>;
  column?: Maybe<Scalars['Int']>;
};

export type IPreferenceItem = {
  __typename?: 'PreferenceItem';
  name?: Maybe<Scalars['String']>;
  type?: Maybe<Scalars['String']>;
  default?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  categoryType?: Maybe<Scalars['String']>;
  settings?: Maybe<Scalars['String']>;
  enum?: Maybe<Array<Maybe<Scalars['String']>>>;
  enumDescriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
};

/** Is a extension of SideBySideEditorInput */
export type IPreferencesEditorInput = IIEditorInput & IIEditorInputWithGroupFields & IISideBySideEditorInput & {
  __typename?: 'PreferencesEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  master?: Maybe<IEditorInput>;
  details?: Maybe<IEditorInput>;
};

export type IPreferencesType = {
  __typename?: 'PreferencesType';
  type?: Maybe<Scalars['String']>;
  data?: Maybe<Array<Maybe<ISetting>>>;
};

export type IPrimaryButtonAction = {
  __typename?: 'PrimaryButtonAction';
  label?: Maybe<Scalars['String']>;
  run?: Maybe<IActionRun>;
};

export type IPrimaryButtonActionInput = {
  label?: Maybe<Scalars['String']>;
  run?: Maybe<IActionRunInput>;
};

export type IProcessMonitoring = {
  __typename?: 'ProcessMonitoring';
  cpu?: Maybe<Scalars['Float']>;
  memory?: Maybe<Scalars['Float']>;
};

export type IProgress = {
  __typename?: 'Progress';
  total?: Maybe<Scalars['Int']>;
  worked?: Maybe<Scalars['Int']>;
};

export type IPromptChoiceInput = {
  /** Label to show for the choice to the user. */
  label?: Maybe<Scalars['String']>;
  /**
   * Primary choices show up as buttons in the notification below the message.
   * Secondary choices show up under the gear icon in the header of the notification.
   */
  isSecondary?: Maybe<Scalars['Boolean']>;
  /**
   * Whether to keep the notification open after the choice was selected
   * by the user. By default, will close the notification upon click.
   */
  keepOpen?: Maybe<Scalars['Boolean']>;
  /** Triggered when the user selects the choice. */
  run?: Maybe<IPromptChoiceRun>;
};

export type IPromptChoiceRun = {
  type?: Maybe<IGraphqlCallType>;
  document?: Maybe<Scalars['AnyObject']>;
  variables?: Maybe<Scalars['AnyObject']>;
};

export type IPromptOptionsCancel = {
  type?: Maybe<IGraphqlCallType>;
  document?: Maybe<Scalars['AnyObject']>;
  variables?: Maybe<Scalars['AnyObject']>;
};

export type IPromptOptionsInput = {
  /**
   * Sticky prompts are not automatically removed after a certain timeout.
   *
   * Note: Prompts of severity ERROR are always sticky.
   */
  sticky?: Maybe<Scalars['Boolean']>;
  /**
   * Silent notifications are not shown to the user unless the notification center is opened.
   * The status bar will still indicate all number of notifications to
   * catch some attention.
   */
  silent?: Maybe<Scalars['Boolean']>;
  /**
   * Will be called if the user closed the notification without picking
   * any  of the provided choices.
   */
  onCancel?: Maybe<IPromptOptionsCancel>;
};

export type IProvideTextDocumentLocationSignature = ITextDocumentPositionParams & ILocation & {
  __typename?: 'ProvideTextDocumentLocationSignature';
  textDocument?: Maybe<ITextDocumentIdentifier>;
  position?: Maybe<IPosition>;
  rangeOrUri?: Maybe<IPosition>;
  uriRangeOrPosition?: Maybe<Scalars['String']>;
  range?: Maybe<IPosition>;
  uri?: Maybe<Scalars['String']>;
};

export type IProvideTextDocumentLocationSignatureInput = {
  textDocument?: Maybe<ITextDocumentIdentifierInput>;
  position?: Maybe<IPositionInput>;
  rangeOrUri?: Maybe<IPositionInput>;
  uriRangeOrPosition?: Maybe<Scalars['String']>;
  range?: Maybe<IPositionInput>;
  uri?: Maybe<Scalars['String']>;
};

export const enum IProvidedRemoteConnectionStates {
  Initializing = 'initializing',
  Disconnected = 'disconnected',
  Connected = 'connected'
};

export type IQuery = {
  __typename?: 'Query';
  contextMenu?: Maybe<IContextMenu>;
  /**  Default Preferences  */
  defaultPreferences?: Maybe<IDefaultPreferencesResponse>;
  defaultSetting?: Maybe<ISetting>;
  /**
   * The default settings for the requested ConfigurationTarget
   * Note: Due to bug in graphql we using  `target: Int` argument instead of  `target:ConfigurationTarget`
   * https://github.com/apollographql/apollo-server/issues/2556
   */
  defaultViewerSettingsSubject: IDefaultSettings;
  dialog?: Maybe<IDialog>;
  /**
   * The CDECode documentation page for the given path, used to serve the content for help
   * pages under the URL path /help on the CDECode instance. If no page exists at the path,
   * null is returned.
   */
  docSitePage?: Maybe<IDocSitePage>;
  editorPart?: Maybe<IEditorPart>;
  editorState?: Maybe<ICodeEditorViewState>;
  existsFile?: Maybe<Scalars['Boolean']>;
  extension?: Maybe<IRegistryExtension>;
  /**  The extension registry.  */
  extensionRegistry: IExtensionRegistry;
  extensions: IRegistryExtensionConnection;
  fileSearch?: Maybe<ISearchComplete>;
  gallery?: Maybe<IGalleryPager>;
  galleryExtension?: Maybe<IGalleryExtension>;
  getChangedEvent?: Maybe<IIContentChangedEvent>;
  getConfigurationData?: Maybe<IConfigurationData>;
  getConfigurationTarget?: Maybe<ConfigurationScope>;
  getContextData?: Maybe<IContext>;
  getContextProperty?: Maybe<IContext>;
  /**  Default settings  */
  getDefaultSettings?: Maybe<Scalars['String']>;
  /**  Default Settings Resources  */
  getDefaultSettingsResource?: Maybe<Scalars['URI']>;
  getEnvironment?: Maybe<IEnvironment>;
  getKeybindings?: Maybe<IKeybindings>;
  getMostCommonlyUsedSettings?: Maybe<Array<Maybe<Scalars['String']>>>;
  getSelectedValue?: Maybe<ISelectedOutput>;
  getViews?: Maybe<Array<Maybe<IViewDescriptor>>>;
  getWorkspace?: Maybe<IWorkspaceData>;
  getWorkspaceFolderContext?: Maybe<IWorkspaceData>;
  getWorkspaceValue?: Maybe<Scalars['AnyObject']>;
  gotoLineQuickAccess?: Maybe<IGoToLineQuickAccess>;
  installed?: Maybe<Array<Maybe<IInstalledExtension>>>;
  instances?: Maybe<Array<Maybe<IExtensionInstance>>>;
  keybindingContextMenu?: Maybe<IKeybindingContextMenu>;
  keybindings?: Maybe<IKeybindings>;
  /** Looks up a node by ID. */
  node?: Maybe<INode>;
  notifications?: Maybe<INotifications>;
  quickInputModel?: Maybe<IQuickInputModel>;
  /** Read the contents of a file identified by the resource as stream. */
  readStreamTextFile?: Maybe<ITextFileStreamContent>;
  readStringStreamTextFile?: Maybe<ITextFilePublishContent>;
  /** Read the contents of a file identified by the resource. */
  readTextFile?: Maybe<ITextFileContent>;
  registerProvider?: Maybe<Scalars['Boolean']>;
  releases?: Maybe<Array<Maybe<IExtensionRelease>>>;
  resolveContent?: Maybe<IFileContent>;
  resolveContents?: Maybe<Array<Maybe<IResolveFileResultWithMetadata>>>;
  resolveFile?: Maybe<IFileStatWithMetadata>;
  resolveFileContent?: Maybe<ITextFileContent>;
  resolveUntitledFileContent?: Maybe<ITextFileContent>;
  selectedResource?: Maybe<IContext>;
  /**
   * Looks up an instance of a type that implements ISettingsSubject (i.e., something that has settings). This can
   * can be a site (which has global settings), an organization, or a user
   */
  settingsSubject?: Maybe<IISettingsSubject>;
  showDialog?: Maybe<IDialogResult>;
  showNotification?: Maybe<Scalars['Boolean']>;
  statusbar?: Maybe<IStatusbar>;
  statusbarItem?: Maybe<IStatusbarItem>;
  textSearch?: Maybe<ISearchComplete>;
  treeViewData?: Maybe<Array<Maybe<ITreeItem>>>;
  untitledResources?: Maybe<Array<Maybe<Scalars['String']>>>;
  userPreferences?: Maybe<IUserPreferencesRes>;
  /**
   * The settings for the viewer. The viewer is either an anonymous visitor (in which case viewer settings is
   * global settings) or an authenticated user (in which case viewer settings are the user's settings).
   */
  viewerSettings: ISettingsCascade;
  workspaces?: Maybe<Array<Maybe<IWorkspaceRes>>>;
};


export type IQueryDefaultViewerSettingsSubjectArgs = {
  target?: Maybe<Scalars['Int']>;
};


export type IQueryDocSitePageArgs = {
  path: Scalars['String'];
};


export type IQueryEditorStateArgs = {
  editorId: Scalars['String'];
  resource: Scalars['URI'];
};


export type IQueryExistsFileArgs = {
  resource: Scalars['URI'];
};


export type IQueryExtensionArgs = {
  extensionID: Scalars['String'];
};


export type IQueryExtensionsArgs = {
  first?: Maybe<Scalars['Int']>;
  query?: Maybe<Scalars['String']>;
  local?: Maybe<Scalars['Boolean']>;
  remote?: Maybe<Scalars['Boolean']>;
  prioritizeExtensionIDs?: Maybe<Array<Scalars['String']>>;
  includeWIP?: Maybe<Scalars['Boolean']>;
};


export type IQueryFileSearchArgs = {
  query?: Maybe<IFileQueryInput>;
};


export type IQueryGalleryArgs = {
  query?: Maybe<IGalleryQueryInput>;
};


export type IQueryGalleryExtensionArgs = {
  extensionID: Scalars['String'];
};


export type IQueryGetChangedEventArgs = {
  resource: Scalars['URI'];
};


export type IQueryGetContextPropertyArgs = {
  keys?: Maybe<Array<Maybe<Scalars['String']>>>;
};


export type IQueryGetDefaultSettingsArgs = {
  target?: Maybe<ConfigurationTarget>;
};


export type IQueryGetDefaultSettingsResourceArgs = {
  configurationTarget?: Maybe<ConfigurationTarget>;
};


export type IQueryGetViewsArgs = {
  containerId: Scalars['String'];
};


export type IQueryGetWorkspaceFolderContextArgs = {
  arg?: Maybe<IArg_Input>;
};


export type IQueryGetWorkspaceValueArgs = {
  value?: Maybe<IWorkspaceValue_Input>;
};


export type IQueryNodeArgs = {
  id: Scalars['ID'];
};


export type IQueryReadStreamTextFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadTextFileOptions_Input>;
};


export type IQueryReadStringStreamTextFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadTextFileOptions_Input>;
};


export type IQueryReadTextFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadTextFileOptions_Input>;
};


export type IQueryRegisterProviderArgs = {
  registrationOptions?: Maybe<ITextDocumentRegistrationOptionsInput>;
  provider?: Maybe<IProvideTextDocumentLocationSignatureInput>;
};


export type IQueryReleasesArgs = {
  extensionID: Scalars['String'];
};


export type IQueryResolveContentArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IReadFileOptions_Input>;
};


export type IQueryResolveContentsArgs = {
  toResolve?: Maybe<Array<Maybe<IResolveAll_ToResolveWithMetadata_Input>>>;
};


export type IQueryResolveFileArgs = {
  resource: Scalars['URI'];
  options?: Maybe<IResolveMetadataFileOptions_Input>;
};


export type IQueryResolveFileContentArgs = {
  resource: Scalars['URI'];
  options?: Maybe<ILoadOptions_Input>;
};


export type IQueryResolveUntitledFileContentArgs = {
  resource: Scalars['URI'];
};


export type IQuerySettingsSubjectArgs = {
  id: Scalars['ID'];
};


export type IQueryShowDialogArgs = {
  dialog?: Maybe<IDialogInput>;
};


export type IQueryShowNotificationArgs = {
  notification?: Maybe<INotificationInput>;
};


export type IQueryStatusbarItemArgs = {
  id?: Maybe<Scalars['String']>;
};


export type IQueryTextSearchArgs = {
  query?: Maybe<ITextQueryInput>;
};


export type IQueryUserPreferencesArgs = {
  user?: Maybe<Scalars['String']>;
};

export const enum IQueryType {
  File = 'File',
  Text = 'Text'
};

export type IQuickInput = {
  __typename?: 'QuickInput';
  title?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  step?: Maybe<Scalars['Int']>;
  totalSteps?: Maybe<Scalars['Int']>;
  enabled?: Maybe<Scalars['Boolean']>;
  ignoreFocusOut?: Maybe<Scalars['Boolean']>;
  value?: Maybe<Scalars['String']>;
  placeholder?: Maybe<Scalars['String']>;
  prompt?: Maybe<Scalars['String']>;
  validationMessage?: Maybe<Scalars['String']>;
};

export type IQuickInputModel = {
  __typename?: 'QuickInputModel';
  show?: Maybe<Scalars['Boolean']>;
  title?: Maybe<Scalars['String']>;
  input?: Maybe<IQuickInput>;
  quickPick?: Maybe<IQuickPick>;
  inputValue?: Maybe<Scalars['String']>;
  selectedValue?: Maybe<Array<Maybe<IQuickPickItem>>>;
};

export type IQuickPick = {
  __typename?: 'QuickPick';
  placeholder?: Maybe<Scalars['String']>;
  canSelectMany?: Maybe<Scalars['Boolean']>;
  autoFocusOnList?: Maybe<Scalars['Boolean']>;
  items?: Maybe<Array<Maybe<IQuickPickItem>>>;
  activeItem?: Maybe<IQuickPickItem>;
  selectedItems?: Maybe<Array<Maybe<IQuickPickItem>>>;
};

export type IQuickPickItem = {
  __typename?: 'QuickPickItem';
  id?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  detail?: Maybe<Scalars['String']>;
  keybinding?: Maybe<IKeybindingItem>;
  italic?: Maybe<Scalars['Boolean']>;
  highlights?: Maybe<IQuickPickItemHighlights>;
  picked?: Maybe<Scalars['Boolean']>;
  alwaysShow?: Maybe<Scalars['Boolean']>;
};

export type IQuickPickItemHighlights = {
  __typename?: 'QuickPickItemHighlights';
  label?: Maybe<Array<Maybe<IMatch>>>;
  description?: Maybe<Array<Maybe<IMatch>>>;
  detail?: Maybe<Array<Maybe<IMatch>>>;
};

export type IQuickPickItemHighlightsInput = {
  label?: Maybe<Array<Maybe<IMatchInput>>>;
  description?: Maybe<Array<Maybe<IMatchInput>>>;
  detail?: Maybe<Array<Maybe<IMatchInput>>>;
};

/**
 * @lsp - A range in a text document expressed as (zero-based) start and end positions. A range is comparable to a
 * section in an editor. Therefore the end position is exclusive. If you want to specify a range that contains a line
 * including the line ending character(s) then use an end pisition denoting the start of the next line. For example:
 * ```
 * {
 *    start: { line: 5, character: 23 },
 *    end : { line 6, character : 0 }
 * }
 * ```
 *
 * @editor - A range in the editor. This interface is suitable for serialization.
 */
export type IRange = {
  __typename?: 'Range';
  /**
   * @lsp
   * The range's start position.
   */
  start?: Maybe<IPosition>;
  /**
   * @lsp
   * The range's end position.
   */
  end?: Maybe<IPosition>;
  /** @editor - Line number on which the range starts (starts at 1). */
  startLineNumber?: Maybe<Scalars['Int']>;
  /** @editor - Column on which the range starts in the line `startLineNumber` (starts at 1). */
  startColumn?: Maybe<Scalars['Int']>;
  /** @editor - Line number on which the range ends. */
  endLineNumber?: Maybe<Scalars['Int']>;
  /** @editor - Column on which the range ends in the line `endLineNumber` */
  endColumn?: Maybe<Scalars['Int']>;
};

export type IRangeInput = {
  endColumn?: Maybe<Scalars['Int']>;
  endLineNumber?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  startLineNumber?: Maybe<Scalars['Int']>;
};

export type IReadFileOptions_Input = {
  /**
   * The optional etag parameter allows to return early from resolving the resource if
   * the contents on disk match the etag. This prevents accumulated reading of resources
   * that have been read already with the same etag.
   * It is the task of the caller to makes sure to handle this error case from the promise.
   */
  etag?: Maybe<Scalars['String']>;
  /**
   * Is an integer specifying where to begin reading from in the file. If position is null,
   * data will be read from the current file position.
   */
  position?: Maybe<Scalars['Int']>;
  /**
   * Is an integer specifying how many bytes to read from the file. By default, all bytes
   * will be read.
   */
  length?: Maybe<Scalars['Int']>;
  /** If provided, the size of the file will be checked agains the limits. */
  limits?: Maybe<IReadFileOptions_Input_Limits>;
};

export type IReadFileOptions_Input_Limits = {
  size?: Maybe<Scalars['Int']>;
  memory?: Maybe<Scalars['Int']>;
};

/** It is a extension to ReadFileOptions_Input with few more options. */
export type IReadTextFileOptions_Input = {
  etag?: Maybe<Scalars['String']>;
  Position?: Maybe<Scalars['Int']>;
  length?: Maybe<Scalars['Int']>;
  limits?: Maybe<IReadFileOptions_Input_Limits>;
  /**
   * The optional acceptTextOnly parameters allows to fail this request early if the file
   * contents are not textual.
   */
  acceptTextOnly?: Maybe<Scalars['Boolean']>;
  /**
   * The optional encoding parameter allows to specify the desired encoding when resolving
   * the contents of the file.
   */
  encoding?: Maybe<Scalars['String']>;
  /** The ioptional guessEncoding parameter allows to guess encoding from content of the file. */
  autoGuessEncoding?: Maybe<Scalars['Boolean']>;
};

export const enum IReadyState {
  /** This window has  not loaded any HTML yet */
  None = 'NONE',
  /** This window is loading HTML */
  Loading = 'LOADING',
  /** This window is navigating to another HTML */
  Navigating = 'NAVIGATING',
  /** This window is done loading HTML */
  Ready = 'READY'
};

export type IRegistryEntry = {
  __typename?: 'RegistryEntry';
  registrationOptions?: Maybe<ITextDocumentRegistrationOptions>;
  provider?: Maybe<Scalars['String']>;
};

/**  An extenion's listing in the extension registry. */
export type IRegistryExtension = INode & {
  __typename?: 'RegistryExtension';
  /**
   *  The unique, opaque, permanent ID of the extension. Do not display this ID to the user; display
   * RegistryExtension.extensionID instead (it is friendlier and still unique, but it can be renamed).
   */
  id: Scalars['ID'];
  /**
   * The UUID of the extension. This identifies the extension externally (along with the origin). The UUID maps
   * 1-t0-1 to RegistryExtension.id.
   */
  uuid: Scalars['String'];
  /**  The publisher of the extension. If this extension is from a remote registry, the publisher may be null. */
  publisher?: Maybe<IRegistryPublisher>;
  /**
   *  The qualified, unique name that refers to this extension, consisting of the registry name (if non-default),
   * publisher's name, and the extension's name, all joined by "/" (for example, "cdecode/my-extension-name").
   */
  extensionID?: Maybe<Scalars['String']>;
  /**  The extension ID without the registry name. */
  extensionIDWithoutRegistry?: Maybe<Scalars['String']>;
  /**  The name of the extension (not including the publisher's name). */
  name: Scalars['String'];
  /**  Latest Published version  */
  version?: Maybe<Scalars['String']>;
  activationEvents?: Maybe<Array<Maybe<Scalars['String']>>>;
  /**  The extension manifest, or null if none is set. */
  manifest?: Maybe<IExtensionManifest>;
  /**  The date when this extension was last updated on the registry. */
  updatedAt?: Maybe<Scalars['String']>;
  /**  The URL to the extension on this CDECode site. */
  url?: Maybe<Scalars['String']>;
  /**
   *  The URL to the extension on the extension registry where it lives (if this is a remote
   * extension). If this extension is local, then this field's value is null.
   */
  remoteURL?: Maybe<Scalars['String']>;
  /**  Whether the registry extension is published on this CDECode site. */
  isLocal?: Maybe<Scalars['Boolean']>;
  /**  Whether the viewer has admin privileges on this registry extension. */
  viewerCanAdminister?: Maybe<Scalars['Boolean']>;
  /**  Extension Releases  */
  releases?: Maybe<Array<Maybe<IExtensionRelease>>>;
};

/**  A list of registry extensions. */
export type IRegistryExtensionConnection = {
  __typename?: 'RegistryExtensionConnection';
  /**  A list of registry extensions. */
  nodes: Array<IRegistryExtension>;
  /**
   * The total count of registry extensions in the connection. This total cound may be larger than the number of
   * nodes in this object when the result is paginated.
   */
  totalCount: Scalars['Int'];
  /**  Pagination information  */
  pageInfo: IPageInfo;
  /**  location of the extension path for example: /extensions/<extension_user>/<extension_name>  */
  url?: Maybe<Scalars['String']>;
  /**
   * Errors that occured while communicating with remote registries to obtain the list of extensions.
   *
   * In order to be able to return local extensions even when the remote registry is unreachable, errors are
   * recorded here instead of in the top-level GraphQL errors list.
   */
  error?: Maybe<Scalars['String']>;
};

/**  A publisher of a registry extension. */
export type IRegistryPublisher = {
  __typename?: 'RegistryPublisher';
  UserId?: Maybe<Scalars['String']>;
};

/**  A list of publishers of extensions in the registry. */
export type IRegistryPublisherConnection = {
  __typename?: 'RegistryPublisherConnection';
  /**  A list of publishers. */
  nodes: Array<IRegistryPublisher>;
  /**
   * The total count of publishers in the connection. This total count may be larger than the number of
   * nodes in the object when result is paginated.
   */
  totalCount: Scalars['Int'];
  /**  Pagination information. */
  pageInfo: IPageInfo;
};

export type IRemoteUserSettings = IISettingsSubject & {
  __typename?: 'RemoteUserSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IRemoveEditor_Input = {
  editorId?: Maybe<Scalars['Int']>;
  resource?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
};

export type IReplaceContentResult = {
  __typename?: 'ReplaceContentResult';
  resource?: Maybe<Scalars['String']>;
  oldText?: Maybe<Scalars['String']>;
  newText?: Maybe<Scalars['String']>;
};

export type IResolveAll_ToResolveWithMetadata_Input = {
  resource?: Maybe<Scalars['URI']>;
  options?: Maybe<IResolveMetadataFileOptions_Input>;
};

export type IResolveAll_ToResolve_Input = {
  resource?: Maybe<Scalars['URI']>;
  options?: Maybe<IResolveFileOptions_Input>;
};

export type IResolveFileOptions_Input = {
  /**
   * Automatically continue resolving children of a directory until the provided resources
   * are found.
   */
  resolveTo?: Maybe<Array<Maybe<Scalars['URI']>>>;
  /** Automatically continue resolving children of a directory if the number of children as 1. */
  resolveSingleChildDescendants?: Maybe<Scalars['Boolean']>;
  /**
   * Will resolve mtime, size and etag of files if enabled. Ths can have a negative impact
   * on performance and thus should only be used when these values are required.
   */
  resolveMetadata?: Maybe<Scalars['Boolean']>;
};

export type IResolveFileResult = {
  __typename?: 'ResolveFileResult';
  stat?: Maybe<IFileStat>;
  success: Scalars['Boolean'];
  /**  The content of a file as stream  */
  value?: Maybe<Scalars['VSBufferReadableStream']>;
};

export type IResolveFileResultWithMetadata = {
  __typename?: 'ResolveFileResultWithMetadata';
  stat?: Maybe<IFileStatWithMetadata>;
  success: Scalars['Boolean'];
};

/** Extension of `ResolveFileOptions_Input` with defined `resolveMedata` */
export type IResolveMetadataFileOptions_Input = {
  resolveTo?: Maybe<Array<Maybe<Scalars['URI']>>>;
  resolveSingleChildDescendants?: Maybe<Scalars['Boolean']>;
  resolveMetadata?: Maybe<Scalars['Boolean']>;
};

/** Extends BaseResource_Input */
export type IResourceDiff_Input = {
  options?: Maybe<ITextEditorOptions_Input>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  forceFile?: Maybe<Scalars['Boolean']>;
  forceUntitled?: Maybe<Scalars['Boolean']>;
  /** The left hand side URI to open inside a diff editor. */
  leftResource: Scalars['URI'];
  /** The right hand side URI to open inside a diff editor. */
  rightResource: Scalars['URI'];
};

/**
 * A read-only text editor input whoes content are made of the provided resource that points to an existing
 * code editor model.
 */
export type IResourceEditorInput = IIEditorInput & IIEditorInputWithGroupFields & {
  __typename?: 'ResourceEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  mode?: Maybe<Scalars['String']>;
  preferredMode?: Maybe<Scalars['String']>;
};

export type IResourceEncoding = {
  __typename?: 'ResourceEncoding';
  encoding?: Maybe<Scalars['String']>;
  hasBOM?: Maybe<Scalars['Boolean']>;
};

export type IResourceMapConfigurationModel = {
  __typename?: 'ResourceMapConfigurationModel';
  resource?: Maybe<Scalars['URI']>;
  contents?: Maybe<Scalars['AnyObject']>;
  keys?: Maybe<Array<Maybe<Scalars['String']>>>;
  overrides?: Maybe<IConfigurationOverrides>;
};

/** Extends BaseResource_Input */
export type IResourceSideBySide_Input = {
  options?: Maybe<ITextEditorOptions_Input>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  forceFile?: Maybe<Scalars['Boolean']>;
  forceUntitled?: Maybe<Scalars['Boolean']>;
  /** The right hand side URI to open inside a side by side editor. */
  masterResource: Scalars['URI'];
  /** The left hand side URI to open inside a side by side editor. */
  detailResource: Scalars['URI'];
};

/** Resource_Input is extension of BaseResourceInput */
export type IResource_Input = {
  options?: Maybe<ITextEditorOptions_Input>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  forceFile?: Maybe<Scalars['Boolean']>;
  forceUntitled?: Maybe<Scalars['Boolean']>;
  /** The resource URL of the resource to open. */
  resource: Scalars['URI'];
  /** The encoding of the text input if known. */
  encoding?: Maybe<Scalars['String']>;
  /**
   * The identifier of the language mode of the text input
   * if known to use when displaying the contents.
   */
  mode?: Maybe<Scalars['String']>;
};

export type IRevealOptions = {
  __typename?: 'RevealOptions';
  select?: Maybe<Scalars['Boolean']>;
  focus?: Maybe<Scalars['Boolean']>;
  expand?: Maybe<Scalars['Boolean']>;
};

export type IRunActionInWindowRequest = {
  __typename?: 'RunActionInWindowRequest';
  id: Scalars['String'];
  from?: Maybe<IRunActionInWindowRequestFrom>;
  args?: Maybe<Array<Maybe<Scalars['AnyObject']>>>;
};

export const enum IRunActionInWindowRequestFrom {
  Menu = 'menu',
  Touchbar = 'touchbar',
  Mouse = 'mouse'
};

export type IRunKeybindingInWindowRequest = {
  __typename?: 'RunKeybindingInWindowRequest';
  userSettingsLabel?: Maybe<Scalars['String']>;
};

export const enum IStatusbar_Item_Id {
  Terminal = 'TERMINAL',
  SelectionStatus = 'SELECTION_STATUS',
  IndentationStatus = 'INDENTATION_STATUS',
  EncodingStatus = 'ENCODING_STATUS',
  EolStatus = 'EOL_STATUS',
  LanguageModeStatus = 'LANGUAGE_MODE_STATUS',
  SyncStatus = 'SYNC_STATUS',
  BranchStatus = 'BRANCH_STATUS'
};

export type ISaveDialogOptions = {
  __typename?: 'SaveDialogOptions';
  title?: Maybe<Scalars['String']>;
  defaultPath?: Maybe<Scalars['String']>;
  buttonLabel?: Maybe<Scalars['String']>;
  filters?: Maybe<Array<Maybe<IFileFilter>>>;
  message?: Maybe<Scalars['String']>;
  nameFieldLabel?: Maybe<Scalars['String']>;
  showTagField?: Maybe<Scalars['Boolean']>;
};

export type ISaveOptions_Input = {
  force?: Maybe<Scalars['Boolean']>;
  reason?: Maybe<ISaveReason>;
  overwriteReadonly?: Maybe<Scalars['Boolean']>;
  overwriteEncoding?: Maybe<Scalars['Boolean']>;
  skipSaveParticipants?: Maybe<Scalars['Boolean']>;
  writeElevated?: Maybe<Scalars['Boolean']>;
};

export const enum ISaveReason {
  Explicit = 'EXPLICIT',
  Auto = 'AUTO',
  FocusChange = 'FOCUS_CHANGE',
  WindowChange = 'WINDOW_CHANGE'
};

export type ISaveWorkspaceRes = {
  __typename?: 'SaveWorkspaceRes';
  updated?: Maybe<Scalars['Boolean']>;
  id?: Maybe<Scalars['String']>;
};

export type IScripts = {
  __typename?: 'Scripts';
  cdebasebuild?: Maybe<Scalars['String']>;
  cdebasepublish?: Maybe<Scalars['String']>;
};

export type ISearch = {
  __typename?: 'Search';
  location?: Maybe<Scalars['String']>;
  smartCase?: Maybe<Scalars['Boolean']>;
  useRipgrep?: Maybe<Scalars['Boolean']>;
  useIgnoreFiles?: Maybe<Scalars['Boolean']>;
  followSymlinks?: Maybe<Scalars['Boolean']>;
  globalFindClipboard?: Maybe<Scalars['Boolean']>;
  quickOpen?: Maybe<ISearchQuickOpen>;
  exclude?: Maybe<Scalars['JSON']>;
};

export type ISearchComplete = IISearchCompleteStats & {
  __typename?: 'SearchComplete';
  limitHit?: Maybe<Scalars['Boolean']>;
  stats: ISearchCompleteStatsStats;
  results?: Maybe<Array<Maybe<IFileMatch>>>;
};

export type ISearchCompleteStatsStats = IFileSearchStats | ITextSearchStats;

export type ISearchCompleteStream = {
  __typename?: 'SearchCompleteStream';
  isEnd?: Maybe<Scalars['Boolean']>;
  limitHit?: Maybe<Scalars['Boolean']>;
  results?: Maybe<Array<Maybe<IFileMatch>>>;
  stats: ISearchCompleteStatsStats;
  part?: Maybe<Scalars['Int']>;
  size?: Maybe<Scalars['Int']>;
};

export type ISearchEngineStats = {
  __typename?: 'SearchEngineStats';
  traversal: Scalars['String'];
  fileWalkTime: Scalars['Int'];
  directoriesWalked: Scalars['Int'];
  filesWalked: Scalars['Int'];
  cmdTime: Scalars['Int'];
  cmdResultCount?: Maybe<Scalars['Int']>;
};

export type ISearchLog = {
  __typename?: 'SearchLog';
  message?: Maybe<Scalars['String']>;
};

/** One folder to search and a set of glob expressions that should be applied. */
export type ISearchPathPattern = {
  __typename?: 'SearchPathPattern';
  searchPath?: Maybe<Scalars['URI']>;
  pattern?: Maybe<Scalars['String']>;
};

export type ISearchProgressItem = IIFileMatch & IISearchProgress & {
  __typename?: 'SearchProgressItem';
  resource?: Maybe<Scalars['URI']>;
  results?: Maybe<Array<Maybe<ITextSearchResult>>>;
  total?: Maybe<Scalars['Int']>;
  worked?: Maybe<Scalars['Int']>;
  message?: Maybe<Scalars['String']>;
};

export type ISearchQuickOpen = {
  __typename?: 'SearchQuickOpen';
  includeSymbols?: Maybe<Scalars['Boolean']>;
};

export type ISearchRange = {
  __typename?: 'SearchRange';
  startLineNumber?: Maybe<Scalars['Int']>;
  startColumn?: Maybe<Scalars['Int']>;
  endLineNumber?: Maybe<Scalars['Int']>;
  endColumn?: Maybe<Scalars['Int']>;
};

export type ISearchStreamInput = {
  _reason?: Maybe<Scalars['String']>;
  folderQueries?: Maybe<Array<Maybe<IFolderQueryInput>>>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  excludePattern?: Maybe<Scalars['AnyObject']>;
  extraFileResources?: Maybe<Array<Maybe<Scalars['URIInput']>>>;
  useRipgrep?: Maybe<Scalars['Boolean']>;
  maxResults?: Maybe<Scalars['Int']>;
  usingSearchPaths?: Maybe<Scalars['Boolean']>;
  filePattern?: Maybe<Scalars['String']>;
  disregardExcludeSettings?: Maybe<Scalars['Boolean']>;
  exists?: Maybe<Scalars['Boolean']>;
  sortByScore?: Maybe<Scalars['Boolean']>;
  cacheKey?: Maybe<Scalars['String']>;
};

export type ISelectEditor_Input = {
  resource: Scalars['String'];
  editorId?: Maybe<Scalars['Int']>;
  name?: Maybe<Scalars['String']>;
};

export type ISelectedOutput = {
  __typename?: 'SelectedOutput';
  title?: Maybe<Scalars['String']>;
  inputValue?: Maybe<Scalars['String']>;
  selectedValue?: Maybe<Array<Maybe<IQuickPickItem>>>;
};

export type ISelectionStatus = IIStatusbarItem & {
  __typename?: 'SelectionStatus';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type ISetStatusMsgInput = {
  id: Scalars['String'];
  message: Scalars['String'];
};

export type ISetting = {
  __typename?: 'Setting';
  /**  name of the settings */
  name?: Maybe<Scalars['String']>;
  range?: Maybe<IRange>;
  key?: Maybe<Scalars['String']>;
  keyRange?: Maybe<IRange>;
  /**  @deprecated  */
  default?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['AnyObject']>;
  valueRange?: Maybe<IRange>;
  description?: Maybe<Array<Maybe<Scalars['String']>>>;
  descriptionIsMarkdown?: Maybe<Scalars['Boolean']>;
  descriptionRanges?: Maybe<Array<Maybe<IRange>>>;
  overrides?: Maybe<Array<Maybe<ISetting>>>;
  overrideOf?: Maybe<ISetting>;
  deprecationMessage?: Maybe<Scalars['String']>;
  scope?: Maybe<ConfigurationScope>;
  type?: Maybe<Array<Maybe<Scalars['String']>>>;
  enum?: Maybe<Array<Maybe<Scalars['String']>>>;
  enumDescriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
  enumDescriptionsAreMarkdown?: Maybe<Scalars['Boolean']>;
  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
  extensionInfo?: Maybe<IConfigurationExtensionInfo>;
};

export const enum ISettingValueType {
  Null = 'Null',
  Enum = 'Enum',
  String = 'String',
  Integer = 'Integer',
  Number = 'Number',
  Boolean = 'Boolean',
  Exclude = 'Exclude',
  Complex = 'Complex',
  NullableInteger = 'NullableInteger',
  NullableNumber = 'NullableNumber'
};

/** Settings is a version of a configuration settings file. */
export type ISettings = {
  __typename?: 'Settings';
  /** The time when this was created.  */
  createdAt?: Maybe<Scalars['String']>;
  /**
   * The stringified JSON contents of the settings. The contents may include "//"-style comments and trailing
   * commas in the JSON.
   */
  contents: Scalars['String'];
};

/** The configuration for all of the relevant settings subjects, plus the merged settings. */
export type ISettingsCascade = {
  __typename?: 'SettingsCascade';
  /**
   * The other settings subjects that are applied with lower precedence that this subject to
   * form the final merged settings. For example, a user in 2 organizations would have the following
   * settings subjects: site (global settings), org 1, org 2 and the user.
   */
  subjects?: Maybe<Array<Maybe<ISettingsSubject>>>;
  /** The effective final merged settings as (stringified) JSON, merged from all of the subjects. */
  final?: Maybe<Scalars['String']>;
  /** The effective final merged settings as Object, merged from all of the subjects. */
  finalConfiguration?: Maybe<IConfiguration>;
};

export type ISettingsGroup = {
  __typename?: 'SettingsGroup';
  id?: Maybe<Scalars['String']>;
  range?: Maybe<IRange>;
  title?: Maybe<Scalars['String']>;
  titleRange?: Maybe<IRange>;
  sections?: Maybe<Array<Maybe<ISettingsSection>>>;
  contributedByExtension?: Maybe<Scalars['Boolean']>;
};

export type ISettingsSection = {
  __typename?: 'SettingsSection';
  titleRange?: Maybe<IRange>;
  title?: Maybe<Scalars['String']>;
  settings?: Maybe<Array<Maybe<ISetting>>>;
};

export type ISettingsSubject = IUserSettings | ILocalUserSettings | IRemoteUserSettings | IFolderSettings | IGlobalSettings | IWorkspaceSettings | IMemorySettings | IDefaultSettings;

export type IShell = {
  __typename?: 'Shell';
  osx?: Maybe<Scalars['String']>;
  linux?: Maybe<Scalars['String']>;
  windows?: Maybe<Scalars['String']>;
  container?: Maybe<Scalars['String']>;
};

export type IShellArgs = {
  __typename?: 'ShellArgs';
  container?: Maybe<Array<Maybe<Scalars['String']>>>;
  windows?: Maybe<Array<Maybe<Scalars['String']>>>;
  linux?: Maybe<Array<Maybe<Scalars['String']>>>;
  osx?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export { SideBySideEditor };

/** Side by side editor inputs that have a master and details side. */
export type ISideBySideEditorInput = IIEditorInput & IIEditorInputWithGroupFields & IISideBySideEditorInput & {
  __typename?: 'SideBySideEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  master?: Maybe<IEditorInput>;
  details?: Maybe<IEditorInput>;
};

export type ISnippet = {
  __typename?: 'Snippet';
  language?: Maybe<Scalars['String']>;
};

export type ISort = {
  key: Scalars['String'];
  value: ISortEnum;
};

export const enum ISortEnum {
  Asc = 'ASC',
  Desc = 'DESC'
};

export type IStatusbar = {
  __typename?: 'Statusbar';
  items?: Maybe<Array<Maybe<IStatusbarItem>>>;
};

export const enum IStatusbarAlignment {
  Left = 'LEFT',
  Right = 'RIGHT'
};

export type IStatusbarEntry = {
  __typename?: 'StatusbarEntry';
  showTabsButtons?: Maybe<Scalars['Boolean']>;
  showIcons?: Maybe<Scalars['Boolean']>;
  showStatusbar?: Maybe<Scalars['Boolean']>;
  text: Scalars['String'];
  ariaLabel?: Maybe<Scalars['String']>;
  tooltip?: Maybe<Scalars['String']>;
  color?: Maybe<Scalars['String']>;
  backgroundColor?: Maybe<Scalars['String']>;
  command?: Maybe<Scalars['String']>;
  arguments?: Maybe<Array<Maybe<Scalars['String']>>>;
  showBeak?: Maybe<Scalars['Boolean']>;
};

export type IStatusbarEntryInput = {
  showTabsButtons?: Maybe<Scalars['Boolean']>;
  showIcons?: Maybe<Scalars['Boolean']>;
  showStatusbar?: Maybe<Scalars['Boolean']>;
  text: Scalars['String'];
  ariaLabel?: Maybe<Scalars['String']>;
  tooltip?: Maybe<Scalars['String']>;
  color?: Maybe<Scalars['String']>;
  backgroundColor?: Maybe<Scalars['String']>;
  command?: Maybe<Scalars['String']>;
  arguments?: Maybe<Array<Maybe<Scalars['String']>>>;
  showBeak?: Maybe<Scalars['Boolean']>;
};

export type IStatusbarItem = ITerminal | ISelectionStatus | IIndentation | IEncodingStatus | IEndOfLineSequence | ILanguageMode | ISyncStatus | IBranchStatus;

export const enum IStorageScope {
  /** The stored data will be scoped to all workspaces of this domain. */
  Global = 'GLOBAL',
  /** The stored data will be scoped to the current workspace. */
  Workspace = 'WORKSPACE'
};

export type IStreamContent = {
  __typename?: 'StreamContent';
  resource?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  mtime?: Maybe<Scalars['BigInt']>;
  etag?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['String']>;
  status?: Maybe<Scalars['String']>;
  encoding?: Maybe<Scalars['String']>;
  linesRange?: Maybe<ILineRange>;
};

export type ISubscription = {
  __typename?: 'Subscription';
  dummy?: Maybe<Scalars['Int']>;
  fileData?: Maybe<Array<Maybe<IFileChange>>>;
  fileOperation?: Maybe<IFileOperationOutput>;
  onDidChangeConfiguration?: Maybe<IIConfigurationChangeEvent>;
  onDidChangeFileSystemProviderRegistrations?: Maybe<IIFileSystemProviderRegistrationEvent>;
  onWillActivateFileSystemProvider?: Maybe<IIFileSystemProviderActivationEvent>;
  /** Doesn't work yet */
  readStreamTextFile?: Maybe<ITextFileStreamContent>;
  /** Streams content in string chunks */
  readStreamTextString?: Maybe<ITextFilePublishContent>;
  searchStreamContent?: Maybe<ISearchCompleteStream>;
};


export type ISubscriptionFileDataArgs = {
  resource: Scalars['URI'];
};


export type ISubscriptionFileOperationArgs = {
  resource: Scalars['URI'];
};


export type ISubscriptionReadStreamTextFileArgs = {
  resource: Scalars['URI'];
};


export type ISubscriptionReadStreamTextStringArgs = {
  resource: Scalars['URI'];
};


export type ISubscriptionSearchStreamContentArgs = {
  input?: Maybe<Scalars['AnyObject']>;
};

export type ISyncStatus = IIStatusbarItem & {
  __typename?: 'SyncStatus';
  id?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  alignment?: Maybe<IStatusbarAlignment>;
  entry?: Maybe<IStatusbarEntry>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export { TabCloseButtonType };

export { TabSizingType };

export type ITerminal = IIStatusbarItem & {
  __typename?: 'Terminal';
  alignment?: Maybe<IStatusbarAlignment>;
  container?: Maybe<Scalars['String']>;
  entry?: Maybe<IStatusbarEntry>;
  id?: Maybe<Scalars['String']>;
  integrated?: Maybe<IIntegrated>;
  labelContainer?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  priority?: Maybe<Scalars['Int']>;
  typeId?: Maybe<IStatusbar_Item_Id>;
};

export type ITextBufferData = {
  __typename?: 'TextBufferData';
  EOL?: Maybe<Scalars['String']>;
  lines?: Maybe<Array<Maybe<Scalars['String']>>>;
  containsRTL?: Maybe<Scalars['Boolean']>;
  isBasicASCII?: Maybe<Scalars['Boolean']>;
};

export type ITextDocumentIdentifier = IITextDocumentIdentifier & {
  __typename?: 'TextDocumentIdentifier';
  uri?: Maybe<Scalars['URI']>;
  languageId?: Maybe<Scalars['String']>;
};

export type ITextDocumentIdentifierInput = {
  uri?: Maybe<Scalars['URI']>;
};

/** An item to transfer a text document from the client to the server. */
export type ITextDocumentItem = IITextDocumentIdentifier & {
  __typename?: 'TextDocumentItem';
  uri?: Maybe<Scalars['URI']>;
  /** The ID of the document's language. This is a well-defined string identifier such as "phython". */
  languageId?: Maybe<Scalars['String']>;
  /** The document's text content. */
  text?: Maybe<Scalars['String']>;
};

export type ITextDocumentItemInput = {
  uri?: Maybe<Scalars['String']>;
  languageId?: Maybe<Scalars['String']>;
  text?: Maybe<Scalars['String']>;
};

export type ITextDocumentPositionParams = {
  textDocument?: Maybe<ITextDocumentIdentifier>;
  position?: Maybe<IPosition>;
};

export type ITextDocumentPositionParamsInput = {
  textDocument?: Maybe<ITextDocumentIdentifierInput>;
  position?: Maybe<IPositionInput>;
};

export type ITextDocumentRegistrationOptions = {
  __typename?: 'TextDocumentRegistrationOptions';
  documentSelector?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type ITextDocumentRegistrationOptionsInput = {
  documentSelector?: Maybe<Array<Maybe<Scalars['String']>>>;
};

/** Extension of EditorOptions_Input */
export type ITextEditorOptions_Input = {
  /**
   * Tells the editor to not receive keyboard focus when the editor is being opened.
   *
   * Will also not activate the group the editor opens in unless the group is already
   * the active one. This behaviour can be overridden via the `activation` option.
   */
  preserveFocus?: Maybe<Scalars['Boolean']>;
  /**
   * This option is only relevant if an editor is opened into a group that is not active
   * already and allows to control if the inactive group should become active, restored
   * or preserved.
   *
   * By default, the editor group will become active unless `preserveFocus` or `inactive`
   * is specified.
   */
  activation?: Maybe<IEditorActivation>;
  /**
   * Tells the editor to reload the editor input in the editor even if it is identical to the one
   * already showing. By default, the editor will not reload the input if it is identical to the
   * one showing.
   */
  forceReload?: Maybe<Scalars['Boolean']>;
  /**
   * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
   *
   * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
   * to the side of another one or into a specific editor group.
   */
  revealIfVisible?: Maybe<Scalars['Boolean']>;
  /**
   * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
   *
   * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
   * to the side of another one or into a specific editor group.
   */
  revealIfOpened?: Maybe<Scalars['Boolean']>;
  /**
   * An editor that is pinned remains in the editor stack even when another editor is being opened.
   * An editor that is not pinned will always get replaced by another editor that is not pinned.
   */
  pinned?: Maybe<Scalars['Boolean']>;
  /**
   * An editor that is sticky moves to the beginning of the editors list within the group and will remain
   * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
   */
  sticky?: Maybe<Scalars['Boolean']>;
  /** The index in the document stack where to insert the editor into when opening. */
  index?: Maybe<Scalars['Int']>;
  /**
   * An active editor that is opened will show its contents directly. Set to true to open an editor
   * in the background.
   *
   * Will also not activate the group the editor opens in unless the group is already
   * the active one. This behaviour can be overridden via the `activation` option.
   */
  inactive?: Maybe<Scalars['Boolean']>;
  /**
   * Will not show an error in case opening the editor fails and thus allows to show a custom error
   * message as needed. By default, an error will be presented as notification if opening was not possible.
   */
  ignoreError?: Maybe<Scalars['Boolean']>;
  /**
   * Allows to override the editor that should be used to display the input:
   * - `undefined`: let the editor decide for itself
   * - `false`: disable overrides
   * - `string`: specific override by id
   */
  override?: Maybe<Scalars['AnyObject']>;
  /**
   * A optional hint to signal in which context the editor opens.
   *
   * If configured to be `EditorOpenContet.USER`, this hint can be
   * used in various places to control the experience. For example,
   * if the editor to open fails with an error, a notification could
   * inform about this in a modal dialog. If the editor opened through
   * some background task, the notification would show in the background,
   * not as a modal dialog.
   */
  context?: Maybe<IEditorOpenContext>;
  /** Text editor selection. */
  selection?: Maybe<ITextEditorSelection_Input>;
  /** Text editor view state. */
  viewState?: Maybe<Scalars['AnyObject']>;
  /**
   * Options to control the text editor selection reveal type.
   * Defaults to TextEditoSelectionRevewalType.Center
   */
  selectionRevealType?: Maybe<ITextEditorSelectionRevealType>;
};

export const enum ITextEditorSelectionRevealType {
  /** Option to scroll vertically or horizontally as necessary and reveal a range centered vertically. */
  Center = 'Center',
  /** Option to scroll vertically or horizontally as necessary and reveal a range centered vertically only if it lies outside the viewport. */
  CenterIfOutsideViewport = 'CenterIfOutsideViewport',
  /** Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top. */
  NearTop = 'NearTop',
  /**
   * Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top.
   * Only if it lies outside the viewport
   */
  NearTopIfOutsideViewport = 'NearTopIfOutsideViewport'
};

export type ITextEditorSelection_Input = {
  startLineNumber: Scalars['Int'];
  startColumn: Scalars['Int'];
  endLineNumber?: Maybe<Scalars['Int']>;
  endColumn?: Maybe<Scalars['Int']>;
};

export type ITextFileContent = IIBaseStat & IIBaseStatWithMetadata & IIBaseTextFileContent & IIFileClientMetadata & {
  __typename?: 'TextFileContent';
  /** Content of the file is modified */
  dirty?: Maybe<Scalars['Boolean']>;
  /** Encoding as reported from disk */
  encoding?: Maybe<Scalars['String']>;
  etag: Scalars['String'];
  /** File is in conflict with storage. */
  inConflictMode?: Maybe<Scalars['Boolean']>;
  /** File is in Error */
  inErrorMode?: Maybe<Scalars['Boolean']>;
  /** File doesn't exist in the storage */
  inOrphanMode?: Maybe<Scalars['Boolean']>;
  /** Pending Save */
  inPendingSave?: Maybe<Scalars['Boolean']>;
  isReadonly?: Maybe<Scalars['Boolean']>;
  mtime: Scalars['BigInt'];
  name: Scalars['String'];
  /** Encoding as chosen by the user */
  preferredEncoding?: Maybe<Scalars['String']>;
  preferredMode?: Maybe<Scalars['String']>;
  resource: Scalars['URI'];
  size: Scalars['Int'];
  /** States the text file editor model can be in. */
  state?: Maybe<IFileModelState>;
  /** The content of a text file. */
  value?: Maybe<Scalars['String']>;
};

export const enum ITextFileOperationResult {
  FileIsBinary = 'FILE_IS_BINARY'
};

export type ITextFilePublishContent = IIBaseTextFileContent & IIBaseStat & {
  __typename?: 'TextFilePublishContent';
  resource: Scalars['URI'];
  name: Scalars['String'];
  mtime?: Maybe<Scalars['BigInt']>;
  etag?: Maybe<Scalars['String']>;
  size?: Maybe<Scalars['Int']>;
  isReadonly?: Maybe<Scalars['Boolean']>;
  streamSeq?: Maybe<Scalars['Int']>;
  encoding?: Maybe<Scalars['String']>;
  /** The content of the file in parts */
  value?: Maybe<Scalars['String']>;
  status?: Maybe<IFileContentStatus>;
};

export type ITextFileStreamContent = IIBaseTextFileContent & IIBaseStatWithMetadata & IIBaseStat & {
  __typename?: 'TextFileStreamContent';
  resource: Scalars['URI'];
  name: Scalars['String'];
  size: Scalars['Int'];
  mtime: Scalars['BigInt'];
  etag: Scalars['String'];
  isReadonly?: Maybe<Scalars['Boolean']>;
  encoding?: Maybe<Scalars['String']>;
  /** The line grouped content of a text file. */
  value?: Maybe<ITextBufferData>;
};

export type ITextQueryInput = {
  _reason?: Maybe<Scalars['String']>;
  folderQueries?: Maybe<Array<Maybe<IFolderQueryInput>>>;
  includePattern?: Maybe<Scalars['AnyObject']>;
  excludePattern?: Maybe<Scalars['AnyObject']>;
  extraFileResources?: Maybe<Array<Maybe<Scalars['URIInput']>>>;
  useRipgrep?: Maybe<Scalars['Boolean']>;
  maxResults?: Maybe<Scalars['Int']>;
  usingSearchPaths?: Maybe<Scalars['Boolean']>;
  type: IQueryType;
  contentPattern: IPatternInfoInput;
  previewOptions?: Maybe<ITextSearchPreviewOptionsInput>;
  maxFileSize?: Maybe<Scalars['Int']>;
  usePCRE2?: Maybe<Scalars['Boolean']>;
  afterContext?: Maybe<Scalars['Int']>;
  beforeContext?: Maybe<Scalars['Int']>;
};

export type ITextSearchContext = {
  __typename?: 'TextSearchContext';
  uri?: Maybe<Scalars['URI']>;
  text: Scalars['String'];
  lineNumber: Scalars['Int'];
};

export type ITextSearchMatch = {
  __typename?: 'TextSearchMatch';
  uri?: Maybe<Scalars['URI']>;
  ranges?: Maybe<Array<Maybe<ISearchRange>>>;
  preview?: Maybe<ITextSearchResultPreview>;
};

export type ITextSearchPreviewOptions = {
  __typename?: 'TextSearchPreviewOptions';
  matchLines: Scalars['Int'];
  charsPerLine: Scalars['Int'];
};

export type ITextSearchPreviewOptionsInput = {
  matchLines: Scalars['Int'];
  charsPerLine: Scalars['Int'];
};

export type ITextSearchResult = ITextSearchMatch | ITextSearchContext;

export type ITextSearchResultPreview = {
  __typename?: 'TextSearchResultPreview';
  text?: Maybe<Scalars['String']>;
  matches?: Maybe<Array<Maybe<ISearchRange>>>;
};

export type ITextSearchStats = {
  __typename?: 'TextSearchStats';
  type?: Maybe<ITextSearchStatsType>;
};

export const enum ITextSearchStatsType {
  TextSearchProvider = 'textSearchProvider',
  SearchProcess = 'searchProcess'
};

export type IThemeLabel = {
  __typename?: 'ThemeLabel';
  label?: Maybe<Scalars['String']>;
  uiTheme?: Maybe<Scalars['String']>;
  path?: Maybe<Scalars['String']>;
};


export type ITreeData_Input = {
  path?: Maybe<Scalars['String']>;
  title?: Maybe<Scalars['String']>;
  subtitle?: Maybe<Scalars['String']>;
  isDirectory?: Maybe<Scalars['Boolean']>;
  active?: Maybe<Scalars['Boolean']>;
  expanded?: Maybe<Scalars['Boolean']>;
  hasChildren?: Maybe<Scalars['Boolean']>;
  childrenGen?: Maybe<Scalars['JSON']>;
};

export type ITreeItem = {
  __typename?: 'TreeItem';
  handle?: Maybe<Scalars['String']>;
  parentHandle?: Maybe<Scalars['String']>;
  collapsibleState?: Maybe<ITreeItemCollapsibleState>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  icon?: Maybe<Scalars['URI']>;
  iconDark?: Maybe<Scalars['URI']>;
  themeIcon?: Maybe<Scalars['String']>;
  resourceUri?: Maybe<Scalars['URI']>;
  tooltip?: Maybe<Scalars['String']>;
  contextValue?: Maybe<Scalars['String']>;
  children?: Maybe<Array<Maybe<ITreeItem>>>;
};

export const enum ITreeItemCollapsibleState {
  None = 'None',
  Collapsed = 'Collapsed',
  Expanded = 'Expanded'
};

export type ITreeViewDescriptor = IIViewDescriptor & {
  __typename?: 'TreeViewDescriptor';
  id: Scalars['String'];
  name?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  order?: Maybe<Scalars['Int']>;
  weight?: Maybe<Scalars['Int']>;
  collapsed?: Maybe<Scalars['Boolean']>;
  canToggleVisibility?: Maybe<Scalars['Boolean']>;
  hideByDefault?: Maybe<Scalars['Boolean']>;
  workspace?: Maybe<Scalars['Boolean']>;
};



export type IUriToOpen = IWorkspaceToOpen | IFolderToOpen | IFileToOpen;

/** An editor input to be used for untitled text buffers. */
export type IUntitledEditorInput = IIEditorInput & IIEditorInputWithGroupFields & {
  __typename?: 'UntitledEditorInput';
  id?: Maybe<Scalars['String']>;
  resource?: Maybe<Scalars['String']>;
  typeId?: Maybe<IEditor_Input_Id>;
  description?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  fileReference?: Maybe<IFileStatWithMetadata>;
  preferredEditorId?: Maybe<Scalars['String']>;
  isSupportsSplitEditor?: Maybe<Scalars['Boolean']>;
  isActive?: Maybe<Scalars['Boolean']>;
  preview?: Maybe<Scalars['Boolean']>;
  isPinned?: Maybe<Scalars['Boolean']>;
  editorId?: Maybe<Scalars['Int']>;
  status?: Maybe<Scalars['String']>;
  closable?: Maybe<Scalars['Boolean']>;
  hasAssociatedFilePath?: Maybe<Scalars['Boolean']>;
  shortDescription?: Maybe<Scalars['String']>;
  mediumDescription?: Maybe<Scalars['String']>;
  longDescription?: Maybe<Scalars['String']>;
  shortTitle?: Maybe<Scalars['String']>;
  mediumTitle?: Maybe<Scalars['String']>;
  longTitle?: Maybe<Scalars['String']>;
  suggestFileName?: Maybe<Scalars['String']>;
  enconding?: Maybe<Scalars['String']>;
  mode?: Maybe<Scalars['String']>;
};

/** Extension of BaseResource_Input */
export type IUntitledResource_Input = {
  options?: Maybe<ITextEditorOptions_Input>;
  label?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  forceFile?: Maybe<Scalars['Boolean']>;
  forceUntitled?: Maybe<Scalars['Boolean']>;
  /**
   * Optional resource. If the resource is not provided a new untitled file is created (e.g. Untitled-1).
   * Otherwise the untitled editor will have an associated path and use that when saving.
   */
  resource?: Maybe<Scalars['URI']>;
  /**
   * Optional file path. Using the file resource will associate the file to the untitled resource.
   *    @deprecated
   */
  filePath?: Maybe<Scalars['String']>;
  /** Optional language of the untitled resource. */
  mode?: Maybe<Scalars['String']>;
  /** Optional contents of the untitled resource. */
  contents?: Maybe<Scalars['String']>;
  /** Optional encoding of the untitled resource. */
  encoding?: Maybe<Scalars['String']>;
};

export type IUpdateDelayedResource = {
  __typename?: 'UpdateDelayedResource';
  resource?: Maybe<Scalars['URI']>;
};

export type IUpdateEntryInput = {
  id?: Maybe<Scalars['String']>;
  alignment?: Maybe<Scalars['String']>;
  entry?: Maybe<IStatusbarEntryInput>;
  priority?: Maybe<Scalars['Int']>;
  container?: Maybe<Scalars['String']>;
  labelContainer?: Maybe<Scalars['String']>;
};

export type IUpdatedResource = {
  __typename?: 'UpdatedResource';
  resource?: Maybe<Scalars['URI']>;
  etag?: Maybe<Scalars['String']>;
};

export type IUserPreferencesRes = {
  __typename?: 'UserPreferencesRes';
  prefs?: Maybe<IIUserPreferences>;
};

/** UserSettings is a combination of LocalUserSettings and RemoteUserSettings */
export type IUserSettings = IISettingsSubject & {
  __typename?: 'UserSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**
   * The latest settings for the user.
   *
   * Only the user and site admins can access this field.
   */
  latestSettings?: Maybe<ISettings>;
  /** The URL to the user's settings. */
  settingsURL: Scalars['URI'];
  /**
   * Whether the viewer has admin privileges on this user. The user has admin privileges on their own user, and
   * site admins have admin privileges on all users.
   */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this user, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   *
   * Only the user and site admins can access this field.
   */
  settingsCascade: ISettingsCascade;
};



export type IView = {
  __typename?: 'View';
  id?: Maybe<Scalars['ID']>;
  name?: Maybe<Scalars['String']>;
};

export type IViewContainer = {
  __typename?: 'ViewContainer';
  id?: Maybe<Scalars['ID']>;
  title?: Maybe<Scalars['String']>;
};

export type IViewDescriptor = IIViewDescriptor & {
  __typename?: 'ViewDescriptor';
  id: Scalars['String'];
  name?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
  order?: Maybe<Scalars['Int']>;
  weight?: Maybe<Scalars['Int']>;
  collapsed?: Maybe<Scalars['Boolean']>;
  canToggleVisibility?: Maybe<Scalars['Boolean']>;
  hideByDefault?: Maybe<Scalars['Boolean']>;
  workspace?: Maybe<Scalars['Boolean']>;
};

export type IViewState = {
  __typename?: 'ViewState';
  scrollTop?: Maybe<Scalars['Int']>;
  scrollTopWithoutViewZones?: Maybe<Scalars['Int']>;
  scrollLeft?: Maybe<Scalars['Int']>;
  firstPosition?: Maybe<IPosition>;
  firstPositionDeltaTop?: Maybe<Scalars['Int']>;
};

export type IViewState_Input = {
  scrollTop?: Maybe<Scalars['Int']>;
  scrollTopWithoutViewZones?: Maybe<Scalars['Int']>;
  scrollLeft?: Maybe<Scalars['Int']>;
  firstPosition?: Maybe<IPositionInput>;
  firstPositionDeltaTop?: Maybe<Scalars['Int']>;
};

export type IWatchOptions_Input = {
  recursive?: Maybe<Scalars['Boolean']>;
  excludes?: Maybe<Array<Maybe<Scalars['String']>>>;
  session?: Maybe<Scalars['String']>;
};

export type IWindowConfiguration = {
  __typename?: 'WindowConfiguration';
  machineId?: Maybe<Scalars['String']>;
  windowId?: Maybe<Scalars['Int']>;
  logLevel?: Maybe<Scalars['String']>;
  mainPid?: Maybe<Scalars['String']>;
  appRoot?: Maybe<Scalars['String']>;
  execPath?: Maybe<Scalars['String']>;
  isInitialStartup?: Maybe<Scalars['Boolean']>;
  nodeCacheDataDir?: Maybe<Scalars['String']>;
  backupPath?: Maybe<Scalars['String']>;
  workspace?: Maybe<IWorkspaceIdentifier>;
  /** A single folder workspace identifier is just the path to the folder. */
  folderUri?: Maybe<Scalars['URI']>;
  remoteAuthority?: Maybe<Scalars['String']>;
  zoomLevel?: Maybe<Scalars['Int']>;
  fullscreen?: Maybe<Scalars['Boolean']>;
  maximized?: Maybe<Scalars['Boolean']>;
  highContrast?: Maybe<Scalars['Boolean']>;
  frameless?: Maybe<Scalars['Boolean']>;
  accessibilitySupport?: Maybe<Scalars['Boolean']>;
  partsSplashPath?: Maybe<Scalars['String']>;
  perfStartTime?: Maybe<Scalars['Int']>;
  perfAppReady?: Maybe<Scalars['Int']>;
  perfWindowLoadTime?: Maybe<Scalars['Int']>;
  perfEntries?: Maybe<Scalars['AnyObject']>;
  filesToOpenOrCreate?: Maybe<Array<Maybe<IPath>>>;
  filesToDiff?: Maybe<Array<Maybe<IPath>>>;
  filesToWait?: Maybe<IPathsToWaitFor>;
  termProgram?: Maybe<Scalars['String']>;
};

export const enum IWorkspaceContextServiceAction {
  GetWorkspace = 'getWorkspace',
  OnDidChangeWorkbenchState = 'onDidChangeWorkbenchState',
  OnDidChangeWorkspaceName = 'onDidChangeWorkspaceName',
  OnDidChangeWorkspaceFolders = 'onDidChangeWorkspaceFolders',
  AddFolders = 'addFolders',
  RemoveFolders = 'removeFolders',
  UpdateFolders = 'updateFolders'
};

export type IWorkspaceData = IIStaticWorkspaceData & {
  __typename?: 'WorkspaceData';
  /** The unique identifier of the workspace. */
  id: Scalars['String'];
  /** Folders in the workspace. */
  folders: Array<Maybe<IWorkspaceFolderData>>;
  /** The location of the workspace configuration */
  configuration?: Maybe<Scalars['URI']>;
  name?: Maybe<Scalars['String']>;
  isUntitled?: Maybe<Scalars['Boolean']>;
};

export type IWorkspaceFolderData = {
  __typename?: 'WorkspaceFolderData';
  /** The associated URI for this workspace folder. */
  uri?: Maybe<Scalars['URI']>;
  /** The name of this workspace folder. Defaults to the basename its [uri-path](#Uri.path) */
  name: Scalars['String'];
  /** The ordinal number of this workspace folder. */
  index: Scalars['Int'];
};

export type IWorkspaceIdentifier = {
  __typename?: 'WorkspaceIdentifier';
  id?: Maybe<Scalars['String']>;
  configPath?: Maybe<Scalars['URI']>;
};

export type IWorkspacePreferenceActivityBar = {
  __typename?: 'WorkspacePreferenceActivityBar';
  visible?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceCommandPalette = {
  __typename?: 'WorkspacePreferenceCommandPalette';
  history?: Maybe<Scalars['Int']>;
  preserveInput?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceEditor = {
  __typename?: 'WorkspacePreferenceEditor';
  centeredLayoutAutoResize?: Maybe<Scalars['Boolean']>;
  closeEmptyGroups?: Maybe<Scalars['Boolean']>;
  closeOnFileDelete?: Maybe<Scalars['Boolean']>;
  enablePreview?: Maybe<Scalars['Boolean']>;
  enablePreviewFromQuickOpen?: Maybe<Scalars['Boolean']>;
  focusRecentEditorAfterClose?: Maybe<Scalars['Boolean']>;
  highlightModifiedTabs?: Maybe<Scalars['Boolean']>;
  labelFormat?: Maybe<Scalars['String']>;
  openPositioning?: Maybe<Scalars['String']>;
  openSideBySideDirection?: Maybe<Scalars['String']>;
  restoreViewState?: Maybe<Scalars['Boolean']>;
  revealIfOpen?: Maybe<Scalars['Boolean']>;
  showIcons?: Maybe<Scalars['Boolean']>;
  showTabs?: Maybe<Scalars['Boolean']>;
  splitSizing?: Maybe<Scalars['String']>;
  tabCloseButton?: Maybe<Scalars['String']>;
  tabSizing?: Maybe<Scalars['String']>;
};

export type IWorkspacePreferenceExperimental = {
  __typename?: 'WorkspacePreferenceExperimental';
  editorAssociations?: Maybe<Array<Maybe<Scalars['String']>>>;
};

export type IWorkspacePreferenceList = {
  __typename?: 'WorkspacePreferenceList';
  automaticKeyboardNavigation?: Maybe<Scalars['Boolean']>;
  horizontalScrolling?: Maybe<Scalars['Boolean']>;
  keyboardNavigation?: Maybe<Scalars['String']>;
  multiSelectModifier?: Maybe<Scalars['String']>;
  openMode?: Maybe<Scalars['String']>;
};

export type IWorkspacePreferencePanel = {
  __typename?: 'WorkspacePreferencePanel';
  defaultLocation?: Maybe<Scalars['String']>;
};

export type IWorkspacePreferenceQuickOpen = {
  __typename?: 'WorkspacePreferenceQuickOpen';
  closeOnFocusLost?: Maybe<Scalars['Boolean']>;
  preserveInput?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceSettings = {
  __typename?: 'WorkspacePreferenceSettings';
  editor?: Maybe<Scalars['String']>;
  enableNaturalLanguageSearch?: Maybe<Scalars['Boolean']>;
  openDefaultKeybindings?: Maybe<Scalars['Boolean']>;
  settingsSearchTocBehavior?: Maybe<Scalars['String']>;
  useSplitJSON?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceSideBar = {
  __typename?: 'WorkspacePreferenceSideBar';
  location?: Maybe<Scalars['String']>;
};

export type IWorkspacePreferenceStatusBar = {
  __typename?: 'WorkspacePreferenceStatusBar';
  visible?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceTips = {
  __typename?: 'WorkspacePreferenceTips';
  enabled?: Maybe<Scalars['Boolean']>;
  horizontalScrolling?: Maybe<Scalars['Boolean']>;
  indent?: Maybe<Scalars['Int']>;
  renderIndentGuides?: Maybe<Scalars['String']>;
};

export type IWorkspacePreferenceView = {
  __typename?: 'WorkspacePreferenceView';
  alwaysShowHeaderActions?: Maybe<Scalars['Boolean']>;
};

export type IWorkspacePreferenceWorkbench = {
  __typename?: 'WorkspacePreferenceWorkbench';
  colorTheme?: Maybe<Scalars['String']>;
  enableExperiments?: Maybe<Scalars['Boolean']>;
  fontAliasing?: Maybe<Scalars['String']>;
  iconTheme?: Maybe<Scalars['String']>;
  startupEditor?: Maybe<Scalars['String']>;
  view?: Maybe<IWorkspacePreferenceView>;
  tips?: Maybe<IWorkspacePreferenceTips>;
  statusBar?: Maybe<IWorkspacePreferenceStatusBar>;
  sideBar?: Maybe<IWorkspacePreferenceSideBar>;
  settings?: Maybe<IWorkspacePreferenceSettings>;
  quickOpen?: Maybe<IWorkspacePreferenceQuickOpen>;
  panel?: Maybe<IWorkspacePreferencePanel>;
  list?: Maybe<IWorkspacePreferenceList>;
  experimental?: Maybe<IWorkspacePreferenceExperimental>;
  editor?: Maybe<IWorkspacePreferenceEditor>;
  commandPalette?: Maybe<IWorkspacePreferenceCommandPalette>;
  activityBar?: Maybe<IWorkspacePreferenceActivityBar>;
};

export type IWorkspaceRes = {
  __typename?: 'WorkspaceRes';
  uri?: Maybe<Scalars['String']>;
};

export type IWorkspaceSettings = IISettingsSubject & {
  __typename?: 'WorkspaceSettings';
  /**  The ID.  */
  id?: Maybe<Scalars['ID']>;
  /**  The latest settings.  */
  latestSettings?: Maybe<ISettings>;
  /**  The URL to the settings.  */
  settingsURL: Scalars['URI'];
  /**  Whether the viewer can modify the subject's settings. */
  viewerCanAdminister: Scalars['Boolean'];
  /**
   * All settings for this subject, and the individual levels in the settings cascade (global > organization > user)
   * that were merged to produce the final merged settings.
   */
  settingsCascade: ISettingsCascade;
};

export type IWorkspaceToOpen = {
  __typename?: 'WorkspaceToOpen';
  workspaceUri: Scalars['URI'];
  label?: Maybe<Scalars['String']>;
};

export type IWorkspaceValue_Input = {
  section?: Maybe<Scalars['String']>;
  overrides?: Maybe<IConfigurationOverrides_Input>;
};

export type IWriteFileOptions_Input = {
  /** The last known modification time of the file. This can be used to prevent dirty writes. */
  mtime?: Maybe<Scalars['BigInt']>;
  /** The etag of the file. This can be used to prevent dirty writes. */
  etag?: Maybe<Scalars['String']>;
};

/** It is an extension to WriteFileOptions_Input with few more options. */
export type IWriteTextFileOptions_Input = {
  mtime?: Maybe<Scalars['BigInt']>;
  etag?: Maybe<Scalars['String']>;
  /** The encoding to use when updating a file. */
  encoding?: Maybe<Scalars['String']>;
  /** If set to true, will enforce the selected encoding and not perform any detection using BOM's. */
  overwriteEncoding?: Maybe<Scalars['Boolean']>;
  /** Whether to overwrite a file even if is readonly. */
  overwriteReadonly?: Maybe<Scalars['Boolean']>;
  /**
   * Whether to write to the file as elevated (admin) user. When setting this option a prompt will
   * ask the user to authenticate as super user.
   */
  writeElevated?: Maybe<Scalars['Boolean']>;
};

export const enum ICommentThread {
  Editable = 'editable'
};

export const enum IScmProviders {
  Git = 'git'
};

export const enum IScmResourceGroups {
  WorkingTree = 'workingTree',
  Merge = 'merge',
  Index = 'index'
};

export type IInstallMutationVariables = Exact<{
  vsix: Scalars['String'];
}>;


export type IInstallMutation = (
  { __typename?: 'Mutation' }
  & { install?: Maybe<(
    { __typename?: 'ExtensionIdentifier' }
    & Pick<IExtensionIdentifier, 'id' | 'uuid'>
  )> }
);

export type IProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'hoverProviderDefinition'>
);

export type IRemoveMutationVariables = Exact<{
  id: Scalars['String'];
}>;


export type IRemoveMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'removeExtension'>
);

export type IExtensionsByLimitQueryVariables = Exact<{
  first: Scalars['Int'];
  prioritizeExtensionIDs: Array<Scalars['String']> | Scalars['String'];
}>;


export type IExtensionsByLimitQuery = (
  { __typename?: 'Query' }
  & { extensionRegistry: (
    { __typename?: 'ExtensionRegistry' }
    & { extensions: (
      { __typename?: 'RegistryExtensionConnection' }
      & { nodes: Array<(
        { __typename?: 'RegistryExtension' }
        & Pick<IRegistryExtension, 'id' | 'url' | 'extensionID' | 'viewerCanAdminister'>
        & { manifest?: Maybe<(
          { __typename?: 'ExtensionManifest' }
          & Pick<IExtensionManifest, 'raw' | 'name' | 'activationEvents'>
        )> }
      )> }
    ) }
  ) }
);

export type IExtensionsQueryVariables = Exact<{ [key: string]: never; }>;


export type IExtensionsQuery = (
  { __typename?: 'Query' }
  & { extensions: (
    { __typename?: 'RegistryExtensionConnection' }
    & { nodes: Array<(
      { __typename?: 'RegistryExtension' }
      & Pick<IRegistryExtension, 'id' | 'url' | 'activationEvents' | 'viewerCanAdminister' | 'extensionID'>
      & { releases?: Maybe<Array<Maybe<(
        { __typename?: 'ExtensionRelease' }
        & Pick<IExtensionRelease, 'version' | 'bundleURL' | 'extensionID'>
      )>>>, manifest?: Maybe<(
        { __typename?: 'ExtensionManifest' }
        & Pick<IExtensionManifest, 'bundleURL' | 'raw' | 'name' | 'main' | 'badges' | 'preview' | 'version' | 'keywords' | 'license' | 'homepage' | 'publisher' | 'categories' | 'description' | 'extensionID' | 'displayName' | 'dependencies' | 'extensionDependencies' | 'bundle' | 'activationEvents'>
        & { assets?: Maybe<Array<Maybe<(
          { __typename?: 'Assets' }
          & Pick<IAssets, 'Type' | 'Content'>
        )>>>, scripts?: Maybe<(
          { __typename?: 'Scripts' }
          & Pick<IScripts, 'cdebasebuild' | 'cdebasepublish'>
        )>, bundles?: Maybe<(
          { __typename?: 'Bundles' }
          & Pick<IBundles, 'server' | 'browser'>
        )>, extension?: Maybe<(
          { __typename?: 'ExtensionPackageType' }
          & Pick<IExtensionPackageType, 'type'>
        )>, engines?: Maybe<(
          { __typename?: 'Engines' }
          & Pick<IEngines, 'node' | 'vscode'>
        )>, author?: Maybe<(
          { __typename?: 'Author' }
          & Pick<IAuthor, 'name'>
        )>, galleryBanner?: Maybe<(
          { __typename?: 'GalleryBanner' }
          & Pick<IGalleryBanner, 'color' | 'theme'>
        )>, contributes?: Maybe<(
          { __typename?: 'ExtensionContributions' }
          & { menus?: Maybe<(
            { __typename?: 'Menus' }
            & { commandPalette?: Maybe<Array<Maybe<(
              { __typename?: 'MenuItemAction' }
              & Pick<IMenuItemAction, 'action' | 'when'>
            )>>>, explorer?: Maybe<(
              { __typename?: 'MenuItemActionContext' }
              & { context?: Maybe<Array<Maybe<(
                { __typename?: 'MenuItemAction' }
                & Pick<IMenuItemAction, 'action' | 'when'>
              )>>> }
            )>, editor?: Maybe<(
              { __typename?: 'MenuItemActionEditor' }
              & { context?: Maybe<Array<Maybe<(
                { __typename?: 'MenuItemAction' }
                & Pick<IMenuItemAction, 'action' | 'when'>
              )>>>, title?: Maybe<(
                { __typename?: 'MenuItemActionEditorTitle' }
                & { own?: Maybe<Array<Maybe<(
                  { __typename?: 'MenuItemAction' }
                  & Pick<IMenuItemAction, 'action' | 'when'>
                )>>>, context?: Maybe<Array<Maybe<(
                  { __typename?: 'MenuItemAction' }
                  & Pick<IMenuItemAction, 'action' | 'when'>
                )>>> }
              )> }
            )> }
          )>, actions?: Maybe<Array<Maybe<(
            { __typename?: 'Actions' }
            & Pick<IActions, 'id' | 'command' | 'title' | 'category'>
            & { actionItem?: Maybe<(
              { __typename?: 'ActionItem' }
              & Pick<IActionItem, 'label' | 'description'>
            )> }
          )>>> }
        )> }
      )> }
    )> }
  ) }
);

export type IGalleryExtensionQueryVariables = Exact<{
  extensionID: Scalars['String'];
}>;


export type IGalleryExtensionQuery = (
  { __typename?: 'Query' }
  & { galleryExtension?: Maybe<(
    { __typename?: 'GalleryExtension' }
    & Pick<IGalleryExtension, 'id' | 'name' | 'icon' | 'version' | 'description' | 'publisher' | 'installCount' | 'publisherDisplayName' | 'rating' | 'ratingCount' | 'displayName'>
    & { assets?: Maybe<(
      { __typename?: 'GalleryExtensionAssets' }
      & { download?: Maybe<(
        { __typename?: 'GalleryExtensionAsset' }
        & Pick<IGalleryExtensionAsset, 'uri' | 'fallbackUri'>
      )> }
    )>, resources?: Maybe<(
      { __typename?: 'GalleryExtensionResources' }
      & Pick<IGalleryExtensionResources, 'icon' | 'readme' | 'manifest' | 'changelog'>
    )> }
  )> }
);

export type IGalleryQueryVariables = Exact<{
  query?: Maybe<IGalleryQueryInput>;
}>;


export type IGalleryQuery = (
  { __typename?: 'Query' }
  & { gallery?: Maybe<(
    { __typename?: 'GalleryPager' }
    & Pick<IGalleryPager, 'page'>
    & { firstPage?: Maybe<Array<Maybe<(
      { __typename?: 'GalleryExtension' }
      & Pick<IGalleryExtension, 'id' | 'name' | 'icon' | 'version' | 'description' | 'publisher' | 'installCount' | 'publisherDisplayName' | 'rating' | 'ratingCount' | 'displayName'>
      & { assets?: Maybe<(
        { __typename?: 'GalleryExtensionAssets' }
        & { download?: Maybe<(
          { __typename?: 'GalleryExtensionAsset' }
          & Pick<IGalleryExtensionAsset, 'uri' | 'fallbackUri'>
        )> }
      )> }
    )>>> }
  )> }
);

export type IInstalledExtensionsQueryVariables = Exact<{ [key: string]: never; }>;


export type IInstalledExtensionsQuery = (
  { __typename?: 'Query' }
  & { installed?: Maybe<Array<Maybe<(
    { __typename?: 'InstalledExtension' }
    & { identifier?: Maybe<(
      { __typename?: 'ExtensionIdentifier' }
      & Pick<IExtensionIdentifier, 'id' | 'uuid'>
    )>, galleryIdentifier?: Maybe<(
      { __typename?: 'ExtensionIdentifier' }
      & Pick<IExtensionIdentifier, 'id' | 'uuid'>
    )>, extension?: Maybe<(
      { __typename?: 'GalleryExtension' }
      & Pick<IGalleryExtension, 'name' | 'id' | 'icon' | 'displayName' | 'installCount' | 'description' | 'version' | 'publisherDisplayName'>
      & { identifier?: Maybe<(
        { __typename?: 'ExtensionIdentifier' }
        & Pick<IExtensionIdentifier, 'id' | 'uuid'>
      )> }
    )> }
  )>>> }
);

export type IViewerSettingsQueryVariables = Exact<{ [key: string]: never; }>;


export type IViewerSettingsQuery = (
  { __typename?: 'Query' }
  & { viewerSettings: (
    { __typename?: 'SettingsCascade' }
    & Pick<ISettingsCascade, 'final'>
  ) }
);

export type IDefaultSettingFragment = (
  { __typename?: 'Setting' }
  & Pick<ISetting, 'key' | 'value' | 'description' | 'descriptionIsMarkdown' | 'deprecationMessage' | 'type' | 'enum' | 'enumDescriptions' | 'enumDescriptionsAreMarkdown' | 'tags'>
);

export type IFilesConfigurationFragment = (
  { __typename?: 'Files' }
  & Pick<IFiles, 'eol' | 'hotExit' | 'encoding' | 'autoSave' | 'autoSaveDelay' | 'defaultLanguage' | 'autoGuessEncoding' | 'insertFinalNewline' | 'trimTrailingWhitespace' | 'useExperimentalFileWatcher' | 'watcherExclude' | 'exclude'>
);

export type IGitConfigurationFragment = (
  { __typename?: 'Git' }
  & Pick<IGit, 'path' | 'enabled' | 'autofetch' | 'countBadge' | 'autorefresh' | 'confirmSync' | 'checkoutType' | 'inputValidation' | 'detectSubmodules' | 'enableSmartCommit' | 'ignoreLimitWarning' | 'ignoreLegacyWarning' | 'enableCommitSigning' | 'defaultCloneDirectory' | 'autoRepositoryDetection' | 'ignoreMissingGitWarning' | 'showInlineOpenFileAction' | 'promptToSaveFilesBeforeCommit'>
  & { decorations?: Maybe<(
    { __typename?: 'GitDecorations' }
    & Pick<IGitDecorations, 'enabled'>
  )> }
);

export type ILanguagesConfigurationFragment = (
  { __typename?: 'Languages' }
  & Pick<ILanguages, 'go' | 'css' | 'html' | 'json' | 'yaml' | 'typescript' | 'javascript'>
);

export type ISearchConfigurationFragment = (
  { __typename?: 'Search' }
  & Pick<ISearch, 'location' | 'smartCase' | 'useRipgrep' | 'useIgnoreFiles' | 'followSymlinks' | 'globalFindClipboard' | 'exclude'>
  & { quickOpen?: Maybe<(
    { __typename?: 'SearchQuickOpen' }
    & Pick<ISearchQuickOpen, 'includeSymbols'>
  )> }
);

export type ISettingRangeFragment = (
  { __typename?: 'Range' }
  & Pick<IRange, 'startLineNumber' | 'startColumn' | 'endLineNumber' | 'endColumn'>
  & { start?: Maybe<(
    { __typename?: 'Position' }
    & Pick<IPosition, 'line' | 'lineNumber' | 'column' | 'character'>
  )>, end?: Maybe<(
    { __typename?: 'Position' }
    & Pick<IPosition, 'line' | 'lineNumber' | 'column' | 'character'>
  )> }
);

export type ITerminalConfigurationFragment = (
  { __typename?: 'Terminal' }
  & { integrated?: Maybe<(
    { __typename?: 'Integrated' }
    & Pick<IIntegrated, 'setLocaleVariables'>
    & { shell?: Maybe<(
      { __typename?: 'Shell' }
      & Pick<IShell, 'osx' | 'linux' | 'windows' | 'container'>
    )>, shellArgs?: Maybe<(
      { __typename?: 'ShellArgs' }
      & Pick<IShellArgs, 'container' | 'windows' | 'osx' | 'linux'>
    )> }
  )> }
);

export type IViewerSettingsFragment = (
  { __typename?: 'SettingsCascade' }
  & Pick<ISettingsCascade, 'final'>
  & { subjects?: Maybe<Array<Maybe<(
    { __typename?: 'UserSettings' }
    & Pick<IUserSettings, 'id' | 'settingsURL'>
    & { latestSettings?: Maybe<(
      { __typename?: 'Settings' }
      & Pick<ISettings, 'contents' | 'createdAt'>
    )>, settingsCascade: (
      { __typename?: 'SettingsCascade' }
      & { finalConfiguration?: Maybe<(
        { __typename?: 'Configuration' }
        & { terminal?: Maybe<(
          { __typename?: 'Terminal' }
          & ITerminalConfigurationFragment
        )>, search?: Maybe<(
          { __typename?: 'Search' }
          & ISearchConfigurationFragment
        )>, languages?: Maybe<(
          { __typename?: 'Languages' }
          & ILanguagesConfigurationFragment
        )>, output?: Maybe<(
          { __typename?: 'Output' }
          & Pick<IOutput, 'maxChannelHistory'>
        )>, files?: Maybe<(
          { __typename?: 'Files' }
          & IFilesConfigurationFragment
        )>, git?: Maybe<(
          { __typename?: 'Git' }
          & IGitConfigurationFragment
        )>, workspace?: Maybe<(
          { __typename?: 'WorkspacePreferenceWorkbench' }
          & IWorkspaceConfigurationFragment
        )> }
      )> }
    ) }
  ) | { __typename?: 'LocalUserSettings' } | { __typename?: 'RemoteUserSettings' } | (
    { __typename?: 'FolderSettings' }
    & Pick<IFolderSettings, 'id' | 'settingsURL'>
    & { latestSettings?: Maybe<(
      { __typename?: 'Settings' }
      & Pick<ISettings, 'contents' | 'createdAt'>
    )>, settingsCascade: (
      { __typename?: 'SettingsCascade' }
      & { finalConfiguration?: Maybe<(
        { __typename?: 'Configuration' }
        & { terminal?: Maybe<(
          { __typename?: 'Terminal' }
          & ITerminalConfigurationFragment
        )>, search?: Maybe<(
          { __typename?: 'Search' }
          & ISearchConfigurationFragment
        )>, languages?: Maybe<(
          { __typename?: 'Languages' }
          & ILanguagesConfigurationFragment
        )>, output?: Maybe<(
          { __typename?: 'Output' }
          & Pick<IOutput, 'maxChannelHistory'>
        )>, files?: Maybe<(
          { __typename?: 'Files' }
          & IFilesConfigurationFragment
        )>, git?: Maybe<(
          { __typename?: 'Git' }
          & IGitConfigurationFragment
        )>, workspace?: Maybe<(
          { __typename?: 'WorkspacePreferenceWorkbench' }
          & IWorkspaceConfigurationFragment
        )> }
      )> }
    ) }
  ) | (
    { __typename?: 'GlobalSettings' }
    & Pick<IGlobalSettings, 'id' | 'settingsURL'>
    & { latestSettings?: Maybe<(
      { __typename?: 'Settings' }
      & Pick<ISettings, 'contents' | 'createdAt'>
    )>, settingsCascade: (
      { __typename?: 'SettingsCascade' }
      & { finalConfiguration?: Maybe<(
        { __typename?: 'Configuration' }
        & { terminal?: Maybe<(
          { __typename?: 'Terminal' }
          & ITerminalConfigurationFragment
        )>, search?: Maybe<(
          { __typename?: 'Search' }
          & ISearchConfigurationFragment
        )>, languages?: Maybe<(
          { __typename?: 'Languages' }
          & ILanguagesConfigurationFragment
        )>, output?: Maybe<(
          { __typename?: 'Output' }
          & Pick<IOutput, 'maxChannelHistory'>
        )>, files?: Maybe<(
          { __typename?: 'Files' }
          & IFilesConfigurationFragment
        )>, git?: Maybe<(
          { __typename?: 'Git' }
          & IGitConfigurationFragment
        )>, workspace?: Maybe<(
          { __typename?: 'WorkspacePreferenceWorkbench' }
          & IWorkspaceConfigurationFragment
        )> }
      )> }
    ) }
  ) | { __typename?: 'WorkspaceSettings' } | { __typename?: 'MemorySettings' } | { __typename?: 'DefaultSettings' }>>> }
);

export type IWorkspaceConfigurationFragment = (
  { __typename?: 'WorkspacePreferenceWorkbench' }
  & Pick<IWorkspacePreferenceWorkbench, 'colorTheme' | 'enableExperiments' | 'fontAliasing' | 'iconTheme' | 'startupEditor'>
  & { view?: Maybe<(
    { __typename?: 'WorkspacePreferenceView' }
    & Pick<IWorkspacePreferenceView, 'alwaysShowHeaderActions'>
  )>, tips?: Maybe<(
    { __typename?: 'WorkspacePreferenceTips' }
    & Pick<IWorkspacePreferenceTips, 'enabled' | 'horizontalScrolling' | 'indent' | 'renderIndentGuides'>
  )>, statusBar?: Maybe<(
    { __typename?: 'WorkspacePreferenceStatusBar' }
    & Pick<IWorkspacePreferenceStatusBar, 'visible'>
  )>, settings?: Maybe<(
    { __typename?: 'WorkspacePreferenceSettings' }
    & Pick<IWorkspacePreferenceSettings, 'editor' | 'enableNaturalLanguageSearch' | 'openDefaultKeybindings' | 'settingsSearchTocBehavior' | 'useSplitJSON'>
  )>, quickOpen?: Maybe<(
    { __typename?: 'WorkspacePreferenceQuickOpen' }
    & Pick<IWorkspacePreferenceQuickOpen, 'closeOnFocusLost' | 'preserveInput'>
  )>, panel?: Maybe<(
    { __typename?: 'WorkspacePreferencePanel' }
    & Pick<IWorkspacePreferencePanel, 'defaultLocation'>
  )>, list?: Maybe<(
    { __typename?: 'WorkspacePreferenceList' }
    & Pick<IWorkspacePreferenceList, 'automaticKeyboardNavigation' | 'horizontalScrolling' | 'keyboardNavigation' | 'multiSelectModifier' | 'openMode'>
  )>, experimental?: Maybe<(
    { __typename?: 'WorkspacePreferenceExperimental' }
    & Pick<IWorkspacePreferenceExperimental, 'editorAssociations'>
  )>, editor?: Maybe<(
    { __typename?: 'WorkspacePreferenceEditor' }
    & Pick<IWorkspacePreferenceEditor, 'centeredLayoutAutoResize' | 'closeEmptyGroups' | 'closeOnFileDelete' | 'enablePreview' | 'enablePreviewFromQuickOpen' | 'focusRecentEditorAfterClose' | 'highlightModifiedTabs' | 'labelFormat' | 'openPositioning' | 'openSideBySideDirection' | 'restoreViewState' | 'revealIfOpen' | 'showIcons' | 'showTabs' | 'splitSizing' | 'tabCloseButton' | 'tabSizing'>
  )>, commandPalette?: Maybe<(
    { __typename?: 'WorkspacePreferenceCommandPalette' }
    & Pick<IWorkspacePreferenceCommandPalette, 'history' | 'preserveInput'>
  )>, activityBar?: Maybe<(
    { __typename?: 'WorkspacePreferenceActivityBar' }
    & Pick<IWorkspacePreferenceActivityBar, 'visible'>
  )> }
);

export type IGetConfigurationTargetMutationVariables = Exact<{
  resource?: Maybe<Scalars['URI']>;
}>;


export type IGetConfigurationTargetMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'getConfigurationTarget'>
);

export type IOpenGlobalKeybindingsSettingsMutationVariables = Exact<{
  textual?: Maybe<Scalars['Boolean']>;
}>;


export type IOpenGlobalKeybindingsSettingsMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openGlobalKeybindingSettings'>
);

export type IOpenPreferenceSettingsMutationVariables = Exact<{
  jsonEditor?: Maybe<Scalars['Boolean']>;
  query?: Maybe<Scalars['String']>;
}>;


export type IOpenPreferenceSettingsMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openPreferenceSettings'>
);

export type IResetSettingMutationVariables = Exact<{
  resource?: Maybe<Scalars['URI']>;
  settingKey?: Maybe<Scalars['String']>;
}>;


export type IResetSettingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'resetSetting'>
);

export type ISaveUserSettingsMutationVariables = Exact<{
  content?: Maybe<Scalars['String']>;
}>;


export type ISaveUserSettingsMutation = (
  { __typename?: 'Mutation' }
  & { saveUserSettings?: Maybe<(
    { __typename?: 'SaveWorkspaceRes' }
    & Pick<ISaveWorkspaceRes, 'id'>
  )> }
);

export type ISaveWorkspaceSettingsMutationVariables = Exact<{ [key: string]: never; }>;


export type ISaveWorkspaceSettingsMutation = (
  { __typename?: 'Mutation' }
  & { saveWorkspaceSettings?: Maybe<(
    { __typename?: 'SaveWorkspaceRes' }
    & Pick<ISaveWorkspaceRes, 'updated'>
  )> }
);

export type ISwitchSettingsMutationVariables = Exact<{
  target?: Maybe<Scalars['Int']>;
  editorId?: Maybe<Scalars['Int']>;
  resource?: Maybe<Scalars['URI']>;
  jsonEditor?: Maybe<Scalars['Boolean']>;
}>;


export type ISwitchSettingsMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'switchSettings'>
);

export type IDefaultPreferencesQueryVariables = Exact<{ [key: string]: never; }>;


export type IDefaultPreferencesQuery = (
  { __typename?: 'Query' }
  & { defaultPreferences?: Maybe<(
    { __typename?: 'DefaultPreferencesResponse' }
    & { preferences?: Maybe<Array<Maybe<(
      { __typename?: 'PreferencesType' }
      & Pick<IPreferencesType, 'type'>
      & { data?: Maybe<Array<Maybe<(
        { __typename?: 'Setting' }
        & Pick<ISetting, 'name' | 'type' | 'default' | 'description' | 'enum' | 'enumDescriptions'>
      )>>> }
    )>>> }
  )> }
);

export type IDefaultSettingsQueryVariables = Exact<{
  target?: Maybe<Scalars['Int']>;
}>;


export type IDefaultSettingsQuery = (
  { __typename?: 'Query' }
  & { defaultViewerSettingsSubject: (
    { __typename?: 'DefaultSettings' }
    & { settingsCascade: (
      { __typename?: 'SettingsCascade' }
      & Pick<ISettingsCascade, 'final'>
      & { finalConfiguration?: Maybe<(
        { __typename?: 'Configuration' }
        & { defaultSetting?: Maybe<Array<Maybe<(
          { __typename?: 'SettingsGroup' }
          & Pick<ISettingsGroup, 'title' | 'id'>
          & { sections?: Maybe<Array<Maybe<(
            { __typename?: 'SettingsSection' }
            & { settings?: Maybe<Array<Maybe<(
              { __typename?: 'Setting' }
              & IDefaultSettingFragment
            )>>> }
          )>>> }
        )>>> }
      )> }
    ) }
  ) }
);

export type IFullConfigurationQueryVariables = Exact<{ [key: string]: never; }>;


export type IFullConfigurationQuery = (
  { __typename?: 'Query' }
  & { viewerSettings: (
    { __typename?: 'SettingsCascade' }
    & Pick<ISettingsCascade, 'final'>
    & { subjects?: Maybe<Array<Maybe<(
      { __typename?: 'UserSettings' }
      & Pick<IUserSettings, 'id' | 'settingsURL'>
      & { latestSettings?: Maybe<(
        { __typename?: 'Settings' }
        & Pick<ISettings, 'contents' | 'createdAt'>
      )>, settingsCascade: (
        { __typename?: 'SettingsCascade' }
        & { finalConfiguration?: Maybe<(
          { __typename?: 'Configuration' }
          & { terminal?: Maybe<(
            { __typename?: 'Terminal' }
            & ITerminalConfigurationFragment
          )>, search?: Maybe<(
            { __typename?: 'Search' }
            & ISearchConfigurationFragment
          )>, languages?: Maybe<(
            { __typename?: 'Languages' }
            & ILanguagesConfigurationFragment
          )>, output?: Maybe<(
            { __typename?: 'Output' }
            & Pick<IOutput, 'maxChannelHistory'>
          )>, files?: Maybe<(
            { __typename?: 'Files' }
            & IFilesConfigurationFragment
          )>, git?: Maybe<(
            { __typename?: 'Git' }
            & IGitConfigurationFragment
          )>, workspace?: Maybe<(
            { __typename?: 'WorkspacePreferenceWorkbench' }
            & IWorkspaceConfigurationFragment
          )> }
        )> }
      ) }
    ) | { __typename?: 'LocalUserSettings' } | { __typename?: 'RemoteUserSettings' } | (
      { __typename?: 'FolderSettings' }
      & Pick<IFolderSettings, 'id' | 'settingsURL'>
      & { latestSettings?: Maybe<(
        { __typename?: 'Settings' }
        & Pick<ISettings, 'contents' | 'createdAt'>
      )>, settingsCascade: (
        { __typename?: 'SettingsCascade' }
        & { finalConfiguration?: Maybe<(
          { __typename?: 'Configuration' }
          & { terminal?: Maybe<(
            { __typename?: 'Terminal' }
            & ITerminalConfigurationFragment
          )>, search?: Maybe<(
            { __typename?: 'Search' }
            & ISearchConfigurationFragment
          )>, languages?: Maybe<(
            { __typename?: 'Languages' }
            & ILanguagesConfigurationFragment
          )>, output?: Maybe<(
            { __typename?: 'Output' }
            & Pick<IOutput, 'maxChannelHistory'>
          )>, files?: Maybe<(
            { __typename?: 'Files' }
            & IFilesConfigurationFragment
          )>, git?: Maybe<(
            { __typename?: 'Git' }
            & IGitConfigurationFragment
          )>, workspace?: Maybe<(
            { __typename?: 'WorkspacePreferenceWorkbench' }
            & IWorkspaceConfigurationFragment
          )> }
        )> }
      ) }
    ) | (
      { __typename?: 'GlobalSettings' }
      & Pick<IGlobalSettings, 'id' | 'settingsURL'>
      & { latestSettings?: Maybe<(
        { __typename?: 'Settings' }
        & Pick<ISettings, 'contents' | 'createdAt'>
      )>, settingsCascade: (
        { __typename?: 'SettingsCascade' }
        & { finalConfiguration?: Maybe<(
          { __typename?: 'Configuration' }
          & { terminal?: Maybe<(
            { __typename?: 'Terminal' }
            & ITerminalConfigurationFragment
          )>, search?: Maybe<(
            { __typename?: 'Search' }
            & ISearchConfigurationFragment
          )>, languages?: Maybe<(
            { __typename?: 'Languages' }
            & ILanguagesConfigurationFragment
          )>, output?: Maybe<(
            { __typename?: 'Output' }
            & Pick<IOutput, 'maxChannelHistory'>
          )>, files?: Maybe<(
            { __typename?: 'Files' }
            & IFilesConfigurationFragment
          )>, git?: Maybe<(
            { __typename?: 'Git' }
            & IGitConfigurationFragment
          )>, workspace?: Maybe<(
            { __typename?: 'WorkspacePreferenceWorkbench' }
            & IWorkspaceConfigurationFragment
          )> }
        )> }
      ) }
    ) | (
      { __typename?: 'WorkspaceSettings' }
      & Pick<IWorkspaceSettings, 'id' | 'settingsURL'>
      & { latestSettings?: Maybe<(
        { __typename?: 'Settings' }
        & Pick<ISettings, 'contents' | 'createdAt'>
      )>, settingsCascade: (
        { __typename?: 'SettingsCascade' }
        & { finalConfiguration?: Maybe<(
          { __typename?: 'Configuration' }
          & { terminal?: Maybe<(
            { __typename?: 'Terminal' }
            & ITerminalConfigurationFragment
          )>, search?: Maybe<(
            { __typename?: 'Search' }
            & ISearchConfigurationFragment
          )>, languages?: Maybe<(
            { __typename?: 'Languages' }
            & ILanguagesConfigurationFragment
          )>, output?: Maybe<(
            { __typename?: 'Output' }
            & Pick<IOutput, 'maxChannelHistory'>
          )>, files?: Maybe<(
            { __typename?: 'Files' }
            & IFilesConfigurationFragment
          )>, git?: Maybe<(
            { __typename?: 'Git' }
            & IGitConfigurationFragment
          )>, workspace?: Maybe<(
            { __typename?: 'WorkspacePreferenceWorkbench' }
            & IWorkspaceConfigurationFragment
          )> }
        )> }
      ) }
    ) | { __typename?: 'MemorySettings' } | { __typename?: 'DefaultSettings' }>>> }
  ) }
);

export type IGetMostCommonlyUsedSettingsQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetMostCommonlyUsedSettingsQuery = (
  { __typename?: 'Query' }
  & Pick<IQuery, 'getMostCommonlyUsedSettings'>
);

export type IWorkspacesQueryVariables = Exact<{ [key: string]: never; }>;


export type IWorkspacesQuery = (
  { __typename?: 'Query' }
  & { workspaces?: Maybe<Array<Maybe<(
    { __typename?: 'WorkspaceRes' }
    & Pick<IWorkspaceRes, 'uri'>
  )>>> }
);

export type IAllContextFragment = (
  { __typename?: 'Context' }
  & Pick<IContext, 'originalResourceScheme' | 'view' | 'viewItem' | 'gitOpenRepositoryCount' | 'isInDiffEditor' | 'isInDiffRightEditor' | 'resourceScheme' | 'resourceFilename' | 'resourceLangId' | 'resource' | 'resourceExtName' | 'resourceSet' | 'isFileSystemResource' | 'inputFocus' | 'suggestWidgetVisible' | 'suggestWidgetMultipleSuggestions' | 'suggestionMakesTextEdit' | 'acceptSuggestionOnEnter' | 'hasOtherSuggestions' | 'groupFocusedInOpenEditors' | 'dirtyEditor' | 'resourceSelectedForCompare' | 'fileCopied' | 'breadcrumbsPossible' | 'breadcrumbsVisible' | 'breadcrumbsActive' | 'canNavigateBack' | 'canNavigateForward' | 'canNavigateToLastEditLocation' | 'dirtyDiffVisible' | 'cancellableOperation' | 'parameterHintsVisible' | 'parameterHintsMultipleSignatures' | 'markdownPreviewFocus' | 'isMac' | 'isLinux' | 'isWindows' | 'remoteAuthority' | 'remoteConnectionState' | 'hasMacNativeTabs' | 'supportsWorkspaces' | 'isDevelopment' | 'workbenchState' | 'workspaceFolderCount' | 'remoteFileDialogVisible' | 'isFullscreen' | 'atEndOfWord' | 'scmRepository' | 'scmProvider' | 'scmResourceGroup' | 'inDiffEditorKey' | 'isDominatedByLongLines' | 'isWordWrapMinified' | 'commentThread' | 'commentThreadisEmpty' | 'commentIsEmpty' | 'commentEditorFocused' | 'interfaceOverviewVisible' | 'inReferenceSearchEditor' | 'referenceSearchVisible' | 'listFocus' | 'listSupportsMultiSelect' | 'listHasSelectionOrFocus' | 'listDoubleSelection' | 'listMultiSelection' | 'listSupportsKeyboardNavigation' | 'WorkbenchListAutomaticKeyboardNavigationKey' | 'accessibilityHelpWidgetVisible' | 'inQuickOpenKey' | 'supportedCodeAction' | 'hasSymbols' | 'hasSnippetCompletions' | 'messageVisible' | 'editorHasCallHierarchyProvider' | 'callHierarchyVisible' | 'searchViewletVisible' | 'searchViewletFocus' | 'inputBoxFocus' | 'searchInputBoxFocus' | 'replaceInputBoxFocus' | 'patternIncludesInputBoxFocus' | 'patternExcludesInputBoxFocus' | 'replaceActive' | 'hasSearchResult' | 'firstMatchFocus' | 'fileMatchOrMatchFocus' | 'fileMatchOrFolderMatchFocus' | 'fileMatchFocus' | 'folderMatchFocus' | 'matchFocus' | 'inRecentFilesPicker' | 'inWindowsPicker' | 'findWidgetVisible' | 'findInputFocussed' | 'replaceInputFocussed' | 'editorTextFocus' | 'editorFocus' | 'textInputFocus' | 'editorReadonly' | 'editorHasSelection' | 'editorHasMultipleSelections' | 'editorTabMoveFocus' | 'isInEmbeddedEditor' | 'canUndo' | 'canRedo' | 'editorLangId' | 'editorHasCompletionItemProvider' | 'editorHasCodeActionsProvider' | 'editorHasDefinitionProvider' | 'editorHasDeclarationProvider' | 'editorHasImplementationProvider' | 'editorHasTypeDefinitionProvider' | 'editorHasHoverProvider' | 'editorHadDocumentHighlightProvider' | 'editorHasDocumentSymbolProvider' | 'editorHasReferenceProvider' | 'editorHasRenameProvider' | 'editorHasSignatureHelpProvider' | 'editorHasDocumentFormattingProvider' | 'editorHasDocumentSelectionFormattingProvider' | 'editorHasMultipleDocumentSelectionFormattingProvider' | 'activeEditor' | 'editorIsOpen' | 'editorPinned' | 'groupActiveEditorDirty' | 'groupEditorsCount' | 'textCompareEditorVisible' | 'textCompareEditorActive' | 'activeEditorGroupEmpty' | 'multipleEditorGroups' | 'inZenMode' | 'inCenteredLayout' | 'splitEditorsVertically' | 'sideBarVisible' | 'sideBarFocus' | 'activeViewlet' | 'activePanel' | 'panelFocus' | 'panelPosition' | 'debugType' | 'debugConfigurationType' | 'debugState' | 'inDebugMode' | 'inDebugRepl' | 'breakpointWidgetVisible' | 'watchExpressionsFocused' | 'variablesFocused' | 'expressionSelected' | 'breakpointSelected' | 'callStackItemType' | 'loadedScriptsSupported' | 'loadedScriptsItemType' | 'focusedSessionIsAttach' | 'stepBackSupported' | 'restartFrameSupported' | 'inSettingsEditor' | 'inSettingsJSONEditor' | 'inSettingsSearch' | 'settingsTocRowFocus' | 'inKeybindings' | 'inKeybindingsSearch' | 'keybindingFocus' | 'explorerViewletVisible' | 'explorerResourceIsFolder' | 'explorerResourceReadonly' | 'explorerResourceIsRoot' | 'explorerResourceCut' | 'explorerResourceMoveableToTrash' | 'filesExplorerFocus' | 'openEditorsVisible' | 'openEditorsFocus' | 'explorerViewletFocus' | 'terminalIsOpen' | 'terminalFocus' | 'terminalTextSelected' | 'terminalFindWidgetVisible' | 'terminalFindWidgetInputFocused' | 'terminalFindWidgetFocused' | 'webviewFindWidgetVisible' | 'taskRunning' | 'referenceSearchTreeFocused' | 'interactivePlaygroundFocus' | 'outlineFiltered' | 'outlineFocused' | 'problemsViewFocus' | 'problemFocus' | 'problemsFilterFocus' | 'relatedInformationFocus' | 'inOutput' | 'activeLogOutput' | 'multiCursorModifier' | 'saveConflictResolutionContext' | 'markersNavigationVisible' | 'hasWordHighlights' | 'profileSessionState' | 'extensionHostProfileRecorded' | 'historyNavigationEnabled' | 'historyNavigationWidget' | 'nonEmptyWorkspace' | 'defaultExtensionViews' | 'searchMarketplaceExtensions' | 'searchInstalledExtensions' | 'searchOutdatedExtensions' | 'searchEnabledExtensions' | 'searchDisabledExtensions' | 'hasInstalledExtensions' | 'searchBuiltInExtensions' | 'recommendedExtensions' | 'defaultRecommendedExtensions' | 'workspaceRecommendations' | 'workspaceFolderRecommendations' | 'addToWorkspaceRecommendations' | 'addToWorkspaceFolderRecommendations'>
);

export type IFinalConfigurationFragment = (
  { __typename?: 'Configuration' }
  & { terminal?: Maybe<(
    { __typename?: 'Terminal' }
    & ITerminalConfigurationFragment
  )>, search?: Maybe<(
    { __typename?: 'Search' }
    & ISearchConfigurationFragment
  )>, languages?: Maybe<(
    { __typename?: 'Languages' }
    & ILanguagesConfigurationFragment
  )>, output?: Maybe<(
    { __typename?: 'Output' }
    & Pick<IOutput, 'maxChannelHistory'>
  )>, files?: Maybe<(
    { __typename?: 'Files' }
    & IFilesConfigurationFragment
  )>, git?: Maybe<(
    { __typename?: 'Git' }
    & IGitConfigurationFragment
  )>, workspace?: Maybe<(
    { __typename?: 'WorkspacePreferenceWorkbench' }
    & IWorkspaceConfigurationFragment
  )> }
);

export type IKeybindingItemFragment = (
  { __typename?: 'KeybindingItem' }
  & Pick<IKeybindingItem, 'command' | 'key' | 'when' | 'source'>
);

export type IKeybindingsFragment = (
  { __typename?: 'Keybindings' }
  & { items?: Maybe<Array<Maybe<(
    { __typename?: 'KeybindingItem' }
    & Pick<IKeybindingItem, 'command' | 'key' | 'when' | 'source'>
  )>>> }
);

export type IPickItemFragment = (
  { __typename?: 'QuickPickItem' }
  & Pick<IQuickPickItem, 'id' | 'label' | 'description' | 'detail' | 'italic' | 'picked' | 'alwaysShow'>
  & { keybinding?: Maybe<(
    { __typename?: 'KeybindingItem' }
    & Pick<IKeybindingItem, 'command' | 'key' | 'when' | 'source'>
  )>, highlights?: Maybe<(
    { __typename?: 'QuickPickItemHighlights' }
    & { label?: Maybe<Array<Maybe<(
      { __typename?: 'Match' }
      & Pick<IMatch, 'start' | 'end'>
    )>>>, description?: Maybe<Array<Maybe<(
      { __typename?: 'Match' }
      & Pick<IMatch, 'start' | 'end'>
    )>>>, detail?: Maybe<Array<Maybe<(
      { __typename?: 'Match' }
      & Pick<IMatch, 'start' | 'end'>
    )>>> }
  )> }
);

export type ISelectedFragment = (
  { __typename?: 'QuickInputModel' }
  & Pick<IQuickInputModel, 'title' | 'inputValue'>
  & { selectedValue?: Maybe<Array<Maybe<(
    { __typename?: 'QuickPickItem' }
    & IPickItemFragment
  )>>> }
);

export type IResourceContextFragment = (
  { __typename?: 'Context' }
  & Pick<IContext, 'resourceScheme' | 'resourceFilename' | 'resource' | 'resourceExtName' | 'resourceSet' | 'isFileSystemResource'>
);

type IStatusbarItem_Terminal_Fragment = (
  { __typename?: 'Terminal' }
  & Pick<ITerminal, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_SelectionStatus_Fragment = (
  { __typename?: 'SelectionStatus' }
  & Pick<ISelectionStatus, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_Indentation_Fragment = (
  { __typename?: 'Indentation' }
  & Pick<IIndentation, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_EncodingStatus_Fragment = (
  { __typename?: 'EncodingStatus' }
  & Pick<IEncodingStatus, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_EndOfLineSequence_Fragment = (
  { __typename?: 'EndOfLineSequence' }
  & Pick<IEndOfLineSequence, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_LanguageMode_Fragment = (
  { __typename?: 'LanguageMode' }
  & Pick<ILanguageMode, 'name' | 'alignment' | 'priority'>
  & { entry?: Maybe<(
    { __typename?: 'StatusbarEntry' }
    & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
  )> }
);

type IStatusbarItem_SyncStatus_Fragment = { __typename?: 'SyncStatus' };

type IStatusbarItem_BranchStatus_Fragment = { __typename?: 'BranchStatus' };

export type IStatusbarItemFragment = IStatusbarItem_Terminal_Fragment | IStatusbarItem_SelectionStatus_Fragment | IStatusbarItem_Indentation_Fragment | IStatusbarItem_EncodingStatus_Fragment | IStatusbarItem_EndOfLineSequence_Fragment | IStatusbarItem_LanguageMode_Fragment | IStatusbarItem_SyncStatus_Fragment | IStatusbarItem_BranchStatus_Fragment;

export type IUpdateConfigurationValueMutationVariables = Exact<{
  key: Scalars['String'];
  value: Scalars['AnyObject'];
  overrides: IConfigurationOverrides_Input;
  target?: Maybe<Scalars['Int']>;
  donotNotifyError?: Maybe<Scalars['Boolean']>;
}>;


export type IUpdateConfigurationValueMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'updateConfigurationValue'>
);

export type ICopyMutationVariables = Exact<{
  value?: Maybe<Scalars['String']>;
}>;


export type ICopyMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'copy'>
);

export type IRunMenuActionMutationVariables = Exact<{
  argument?: Maybe<IActionRunInput>;
}>;


export type IRunMenuActionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'runMenuAction'>
);

export type IHideContextMenuMutationVariables = Exact<{ [key: string]: never; }>;


export type IHideContextMenuMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'hideContextMenu'>
);

export type IShowContextMenuMutationVariables = Exact<{
  delegate?: Maybe<IContextMenuInput>;
}>;


export type IShowContextMenuMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'showContextMenu'>
);

export type ICloseDialogMutationVariables = Exact<{ [key: string]: never; }>;


export type ICloseDialogMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'closeDialog'>
);

export type IShowMutationVariables = Exact<{
  dialog?: Maybe<IDialogInput>;
}>;


export type IShowMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'show'>
);

export type IOpenEditorResourceInputMutationVariables = Exact<{
  editor: IResource_Input;
  group?: Maybe<Scalars['Int']>;
}>;


export type IOpenEditorResourceInputMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openEditorWithResourceInput'>
);

export type IOpenEditorMutationVariables = Exact<{
  content: IOpenEditor_Input;
  options?: Maybe<IEditorOpenOptions_Input>;
}>;


export type IOpenEditorMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openEditor'>
);

export type IGoToLineMutationVariables = Exact<{
  range?: Maybe<ILineRangeInput>;
}>;


export type IGoToLineMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'gotoLine'>
);

export type IHighlightLineMutationVariables = Exact<{
  range?: Maybe<ILineRangeInput>;
}>;


export type IHighlightLineMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'highlightLine'>
);

export type IJsonEditingWriteMutationVariables = Exact<{
  resource?: Maybe<Scalars['URI']>;
  value?: Maybe<IIjsonValueInput>;
  save?: Maybe<Scalars['Boolean']>;
}>;


export type IJsonEditingWriteMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'jsonWrite'>
);

export type IChangeKeybindingMutationVariables = Exact<{
  editItem?: Maybe<IKeybindingItemInput>;
  selectedIndex?: Maybe<Scalars['Int']>;
  isOpenDialog?: Maybe<Scalars['Boolean']>;
}>;


export type IChangeKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'changeKeybinding'>
);

export type IChangeWhenExpressionMutationVariables = Exact<{
  editItem?: Maybe<IKeybindingItemInput>;
  editWhenIndex?: Maybe<Scalars['Int']>;
  newWhen?: Maybe<Scalars['String']>;
}>;


export type IChangeWhenExpressionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'changeWhenExpression'>
);

export type IEditKeybindingMutationVariables = Exact<{
  keybindingItem?: Maybe<IKeybindingItemInput>;
  key?: Maybe<Scalars['String']>;
  when?: Maybe<Scalars['String']>;
}>;


export type IEditKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'editKeybinding'>
);

export type IHideKeybindingDialogMutationVariables = Exact<{ [key: string]: never; }>;


export type IHideKeybindingDialogMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'hideKeybindingDialog'>
);

export type ILookupKeybindingMutationVariables = Exact<{
  commandId?: Maybe<Scalars['String']>;
}>;


export type ILookupKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'lookupKeybinding'>
);

export type IRegisterKeybindingMutationVariables = Exact<{
  keybinding?: Maybe<IKeybindingInput>;
}>;


export type IRegisterKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'registerKeybinding'>
);

export type IRemoveKeybindingMutationVariables = Exact<{
  keybindingItem?: Maybe<IKeybindingItemInput>;
}>;


export type IRemoveKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'removeKeybinding'>
);

export type IResetKeybindingMutationVariables = Exact<{
  keybindingItem?: Maybe<IKeybindingItemInput>;
}>;


export type IResetKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'resetKeybinding'>
);

export type IResolveKeyboardEventMutationVariables = Exact<{
  keyboardEvent?: Maybe<IKeyboardEventInput>;
}>;


export type IResolveKeyboardEventMutation = (
  { __typename?: 'Mutation' }
  & { resolveKeyboardEvent?: Maybe<(
    { __typename?: 'KeyboardEvent_output' }
    & Pick<IKeyboardEvent_Output, 'label' | 'key'>
  )> }
);

export type ISearchKeybindingMutationVariables = Exact<{
  value?: Maybe<Scalars['String']>;
}>;


export type ISearchKeybindingMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'searchKeybinding'>
);

export type ISetSelectedKeybindingIndexMutationVariables = Exact<{
  index?: Maybe<Scalars['Int']>;
}>;


export type ISetSelectedKeybindingIndexMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'setSelectedKeybindingIndex'>
);

export type IStopEditWhenExpressionMutationVariables = Exact<{ [key: string]: never; }>;


export type IStopEditWhenExpressionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'stopEditWhenExpression'>
);

export type IAddNotificationMutationVariables = Exact<{
  notification?: Maybe<INotificationInput>;
}>;


export type IAddNotificationMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'addNotification'>
);

export type ICloseNotificationMutationVariables = Exact<{
  index?: Maybe<Scalars['Int']>;
}>;


export type ICloseNotificationMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'closeNotification'>
);

export type IHandlerMutationVariables = Exact<{
  arg?: Maybe<IActionRunInput>;
}>;


export type IHandlerMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'handler'>
);

export type IOpenEditorFileMutationVariables = Exact<{
  content: IOpenEditor_Input;
  options?: Maybe<IEditorOpenOptions_Input>;
}>;


export type IOpenEditorFileMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openFile'>
);

export type IHideInputModelMutationVariables = Exact<{ [key: string]: never; }>;


export type IHideInputModelMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'hideInputModel'>
);

export type ISetSelectedMutationVariables = Exact<{
  selectedValue?: Maybe<Array<Maybe<IPickItem>> | Maybe<IPickItem>>;
  inputValue?: Maybe<Scalars['String']>;
}>;


export type ISetSelectedMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'setSelected'>
);

export type IShowInputMutationVariables = Exact<{
  options?: Maybe<IInputOptions>;
}>;


export type IShowInputMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'showInput'>
);

export type IShowPickInputMutationVariables = Exact<{
  items?: Maybe<Array<Maybe<IPickItem>> | Maybe<IPickItem>>;
  options?: Maybe<IPickInputOptions>;
}>;


export type IShowPickInputMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'showPickInput'>
);

export type IAddEntryMutationVariables = Exact<{
  arg?: Maybe<IAddEntryInput>;
}>;


export type IAddEntryMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'addEntry'>
);

export type IRemoveStatusbarEntryMutationVariables = Exact<{
  id: Scalars['ID'];
}>;


export type IRemoveStatusbarEntryMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'removeStatusbarEntry'>
);

export type ISetStatusMessageMutationVariables = Exact<{
  arg?: Maybe<ISetStatusMsgInput>;
}>;


export type ISetStatusMessageMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'setStatusMessage'>
);

export type IUpdateStatusbarEntryMutationVariables = Exact<{
  arg?: Maybe<IUpdateEntryInput>;
}>;


export type IUpdateStatusbarEntryMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'updateStatusbarEntry'>
);

export type IAddFoldersMutationVariables = Exact<{
  folders?: Maybe<Array<Maybe<IFolderInput>> | Maybe<IFolderInput>>;
  index?: Maybe<Scalars['Int']>;
}>;


export type IAddFoldersMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'addFolders'>
);

export type IChangeWorkspaceMutationVariables = Exact<{
  args?: Maybe<IArgsInput>;
}>;


export type IChangeWorkspaceMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'changeWorkspace'>
);

export type IRemoveFoldersMutationVariables = Exact<{
  folders?: Maybe<Array<Maybe<Scalars['URI']>> | Maybe<Scalars['URI']>>;
}>;


export type IRemoveFoldersMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'removeFolders'>
);

export type IUpdateFoldersMutationVariables = Exact<{
  foldersToAdd?: Maybe<Array<Maybe<IFolderInput>> | Maybe<IFolderInput>>;
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>> | Maybe<Scalars['URI']>>;
  index?: Maybe<Scalars['Int']>;
}>;


export type IUpdateFoldersMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'updateFolders'>
);

export type IFinalConfiguration_WsQueryVariables = Exact<{ [key: string]: never; }>;


export type IFinalConfiguration_WsQuery = (
  { __typename?: 'Query' }
  & { viewerSettings: (
    { __typename?: 'SettingsCascade' }
    & { finalConfiguration?: Maybe<(
      { __typename?: 'Configuration' }
      & IFinalConfigurationFragment
    )> }
  ) }
);

export type IGetContextQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetContextQuery = (
  { __typename?: 'Query' }
  & { getContextData?: Maybe<(
    { __typename?: 'Context' }
    & IAllContextFragment
  )> }
);

export type IContextMenuQueryVariables = Exact<{ [key: string]: never; }>;


export type IContextMenuQuery = (
  { __typename?: 'Query' }
  & { contextMenu?: Maybe<(
    { __typename?: 'ContextMenu' }
    & Pick<IContextMenu, 'id' | 'isShow'>
    & { anchor?: Maybe<(
      { __typename?: 'Anchor' }
      & Pick<IAnchor, 'x' | 'y' | 'height' | 'width'>
    )>, menuItems?: Maybe<Array<Maybe<(
      { __typename?: 'MenuItem' }
      & Pick<IMenuItem, 'id' | 'label' | 'enabled'>
      & { run?: Maybe<(
        { __typename?: 'ActionRun' }
        & Pick<IActionRun, 'type' | 'document' | 'variables'>
      )> }
    )>>> }
  )> }
);

export type IDialogQueryVariables = Exact<{ [key: string]: never; }>;


export type IDialogQuery = (
  { __typename?: 'Query' }
  & { dialog?: Maybe<(
    { __typename?: 'Dialog' }
    & Pick<IDialog, 'dialogType' | 'secondaryButton'>
    & { detail?: Maybe<Array<Maybe<(
      { __typename?: 'Detail' }
      & Pick<IDetail, 'inputName' | 'label' | 'placeholder' | 'defaultValue' | 'required'>
      & { inputType?: Maybe<(
        { __typename?: 'InputTypeDetail' }
        & Pick<IInputTypeDetail, 'type' | 'options'>
      )> }
    )>>>, primaryButton?: Maybe<(
      { __typename?: 'PrimaryButtonAction' }
      & Pick<IPrimaryButtonAction, 'label'>
      & { run?: Maybe<(
        { __typename?: 'ActionRun' }
        & Pick<IActionRun, 'type' | 'document' | 'variables'>
      )> }
    )>, checkbox?: Maybe<(
      { __typename?: 'CheckboxOptions' }
      & Pick<ICheckboxOptions, 'label' | 'checked'>
    )> }
  )> }
);

export type IShowDialogQueryVariables = Exact<{
  dialog?: Maybe<IDialogInput>;
}>;


export type IShowDialogQuery = (
  { __typename?: 'Query' }
  & { showDialog?: Maybe<(
    { __typename?: 'DialogResult' }
    & Pick<IDialogResult, 'confirmed' | 'checkboxChecked'>
  )> }
);

export type IGoToLineQuickAccessQueryVariables = Exact<{ [key: string]: never; }>;


export type IGoToLineQuickAccessQuery = (
  { __typename?: 'Query' }
  & { gotoLineQuickAccess?: Maybe<(
    { __typename?: 'GoToLineQuickAccess' }
    & Pick<IGoToLineQuickAccess, 'highlight' | 'focus'>
    & { range?: Maybe<(
      { __typename?: 'LineRange' }
      & Pick<ILineRange, 'startLine' | 'startColumn' | 'endLine' | 'endColumn'>
    )> }
  )> }
);

export type IGetKeybindingsQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetKeybindingsQuery = (
  { __typename?: 'Query' }
  & { getKeybindings?: Maybe<(
    { __typename?: 'Keybindings' }
    & { items?: Maybe<Array<Maybe<(
      { __typename?: 'KeybindingItem' }
      & Pick<IKeybindingItem, 'command' | 'key' | 'when' | 'source'>
    )>>> }
  )> }
);

export type IKeybindingContextMenuQueryVariables = Exact<{ [key: string]: never; }>;


export type IKeybindingContextMenuQuery = (
  { __typename?: 'Query' }
  & { keybindingContextMenu?: Maybe<(
    { __typename?: 'KeybindingContextMenu' }
    & Pick<IKeybindingContextMenu, 'selectedItemIndex' | 'editWhenIndex' | 'newWhen' | 'isOpenDialog' | 'search'>
    & { editItem?: Maybe<(
      { __typename?: 'EditKeybindingItem' }
      & Pick<IEditKeybindingItem, 'command' | 'key' | 'when' | 'isDefault'>
    )> }
  )> }
);

export type IKeybindingsQueryVariables = Exact<{ [key: string]: never; }>;


export type IKeybindingsQuery = (
  { __typename?: 'Query' }
  & { keybindings?: Maybe<(
    { __typename?: 'Keybindings' }
    & { items?: Maybe<Array<Maybe<(
      { __typename?: 'KeybindingItem' }
      & Pick<IKeybindingItem, 'command' | 'key' | 'when' | 'source'>
    )>>> }
  )> }
);

export type INotificationsQueryVariables = Exact<{ [key: string]: never; }>;


export type INotificationsQuery = (
  { __typename?: 'Query' }
  & { notifications?: Maybe<(
    { __typename?: 'Notifications' }
    & { notifications?: Maybe<Array<Maybe<(
      { __typename?: 'Notification' }
      & Pick<INotification, 'index' | 'severity' | 'message' | 'sticky'>
      & { actions?: Maybe<(
        { __typename?: 'NotificationActions' }
        & { primary?: Maybe<Array<Maybe<(
          { __typename?: 'Action' }
          & Pick<IAction, 'id' | 'label' | 'tooltip' | 'class' | 'enabled' | 'checked' | 'radio'>
          & { run?: Maybe<(
            { __typename?: 'ActionRun' }
            & Pick<IActionRun, 'type' | 'document' | 'variables'>
          )> }
        )>>>, secondary?: Maybe<Array<Maybe<(
          { __typename?: 'Action' }
          & Pick<IAction, 'id' | 'label' | 'tooltip' | 'class' | 'enabled' | 'checked' | 'radio'>
          & { run?: Maybe<(
            { __typename?: 'ActionRun' }
            & Pick<IActionRun, 'type' | 'document' | 'variables'>
          )> }
        )>>> }
      )> }
    )>>> }
  )> }
);

export type IShowNotificationQueryVariables = Exact<{
  notification?: Maybe<INotificationInput>;
}>;


export type IShowNotificationQuery = (
  { __typename?: 'Query' }
  & Pick<IQuery, 'showNotification'>
);

export type IGetSelectedValueQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetSelectedValueQuery = (
  { __typename?: 'Query' }
  & { quickInputModel?: Maybe<(
    { __typename?: 'QuickInputModel' }
    & Pick<IQuickInputModel, 'title' | 'inputValue'>
    & { selectedValue?: Maybe<Array<Maybe<(
      { __typename?: 'QuickPickItem' }
      & IPickItemFragment
    )>>> }
  )> }
);

export type IQuickInputModelQueryVariables = Exact<{ [key: string]: never; }>;


export type IQuickInputModelQuery = (
  { __typename?: 'Query' }
  & { quickInputModel?: Maybe<(
    { __typename?: 'QuickInputModel' }
    & Pick<IQuickInputModel, 'show'>
    & { input?: Maybe<(
      { __typename?: 'QuickInput' }
      & Pick<IQuickInput, 'title' | 'description' | 'enabled' | 'ignoreFocusOut' | 'value' | 'placeholder' | 'prompt' | 'validationMessage'>
    )>, quickPick?: Maybe<(
      { __typename?: 'QuickPick' }
      & Pick<IQuickPick, 'placeholder' | 'canSelectMany' | 'autoFocusOnList'>
      & { items?: Maybe<Array<Maybe<(
        { __typename?: 'QuickPickItem' }
        & IPickItemFragment
      )>>>, activeItem?: Maybe<(
        { __typename?: 'QuickPickItem' }
        & IPickItemFragment
      )>, selectedItems?: Maybe<Array<Maybe<(
        { __typename?: 'QuickPickItem' }
        & IPickItemFragment
      )>>> }
    )> }
  )> }
);

export type IStatusbarQueryVariables = Exact<{ [key: string]: never; }>;


export type IStatusbarQuery = (
  { __typename?: 'Query' }
  & { statusbar?: Maybe<(
    { __typename?: 'Statusbar' }
    & { items?: Maybe<Array<Maybe<(
      { __typename?: 'Terminal' }
      & Pick<ITerminal, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'SelectionStatus' }
      & Pick<ISelectionStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'Indentation' }
      & Pick<IIndentation, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'EncodingStatus' }
      & Pick<IEncodingStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'EndOfLineSequence' }
      & Pick<IEndOfLineSequence, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'LanguageMode' }
      & Pick<ILanguageMode, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'SyncStatus' }
      & Pick<ISyncStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    ) | (
      { __typename?: 'BranchStatus' }
      & Pick<IBranchStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
      & { entry?: Maybe<(
        { __typename?: 'StatusbarEntry' }
        & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
      )> }
    )>>> }
  )> }
);

export type IStatusbarItemQueryVariables = Exact<{
  id?: Maybe<Scalars['String']>;
}>;


export type IStatusbarItemQuery = (
  { __typename?: 'Query' }
  & { statusbarItem?: Maybe<(
    { __typename?: 'Terminal' }
    & Pick<ITerminal, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'SelectionStatus' }
    & Pick<ISelectionStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'Indentation' }
    & Pick<IIndentation, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'EncodingStatus' }
    & Pick<IEncodingStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'EndOfLineSequence' }
    & Pick<IEndOfLineSequence, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'LanguageMode' }
    & Pick<ILanguageMode, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'SyncStatus' }
    & Pick<ISyncStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  ) | (
    { __typename?: 'BranchStatus' }
    & Pick<IBranchStatus, 'id' | 'name' | 'alignment' | 'priority' | 'typeId'>
    & { entry?: Maybe<(
      { __typename?: 'StatusbarEntry' }
      & Pick<IStatusbarEntry, 'showTabsButtons' | 'showIcons' | 'showStatusbar' | 'text' | 'ariaLabel' | 'tooltip' | 'color' | 'backgroundColor' | 'command' | 'arguments' | 'showBeak'>
    )> }
  )> }
);

export type IGetViewsQueryVariables = Exact<{
  containerId: Scalars['String'];
}>;


export type IGetViewsQuery = (
  { __typename?: 'Query' }
  & { getViews?: Maybe<Array<Maybe<(
    { __typename?: 'ViewDescriptor' }
    & Pick<IViewDescriptor, 'id' | 'name'>
  )>>> }
);

export type IGetWorkspaceQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetWorkspaceQuery = (
  { __typename?: 'Query' }
  & { getWorkspace?: Maybe<(
    { __typename?: 'WorkspaceData' }
    & Pick<IWorkspaceData, 'id' | 'name' | 'configuration'>
    & { folders: Array<Maybe<(
      { __typename?: 'WorkspaceFolderData' }
      & Pick<IWorkspaceFolderData, 'uri' | 'name' | 'index'>
    )>> }
  )> }
);

export type IGetConfigurationDataFragment = (
  { __typename?: 'ConfigurationData' }
  & { defaults?: Maybe<(
    { __typename?: 'ConfigurationModel' }
    & Pick<IConfigurationModel, 'contents' | 'keys'>
    & { overrides?: Maybe<Array<Maybe<(
      { __typename?: 'Overrides' }
      & Pick<IOverrides, 'contents' | 'identifiers'>
    )>>> }
  )>, user?: Maybe<(
    { __typename?: 'ConfigurationModel' }
    & Pick<IConfigurationModel, 'contents' | 'keys'>
    & { overrides?: Maybe<Array<Maybe<(
      { __typename?: 'Overrides' }
      & Pick<IOverrides, 'contents' | 'identifiers'>
    )>>> }
  )>, workspace?: Maybe<(
    { __typename?: 'ConfigurationModel' }
    & Pick<IConfigurationModel, 'contents' | 'keys'>
    & { overrides?: Maybe<Array<Maybe<(
      { __typename?: 'Overrides' }
      & Pick<IOverrides, 'contents' | 'identifiers'>
    )>>> }
  )>, folders?: Maybe<Array<Maybe<(
    { __typename?: 'FolderConfigurationModel' }
    & Pick<IFolderConfigurationModel, 'id' | 'keys' | 'contents'>
    & { overrides?: Maybe<(
      { __typename?: 'ConfigurationOverrides' }
      & Pick<IConfigurationOverrides, 'overrideIdentifier' | 'resource'>
    )> }
  )>>> }
);

export type IINotificationMessageFragment = (
  { __typename?: 'NotificationMessage' }
  & Pick<INotificationMessage, 'raw' | 'value'>
  & { links?: Maybe<Array<Maybe<(
    { __typename?: 'MessageLink' }
    & Pick<IMessageLink, 'name' | 'href' | 'offset' | 'length'>
  )>>> }
);

export type INotificationMessageFragment = (
  { __typename?: 'NotificationMessage' }
  & { original?: Maybe<(
    { __typename?: 'NotificationMessage' }
    & IINotificationMessageFragment
  )> }
  & IINotificationMessageFragment
);

export type INotificationFragment = (
  { __typename?: 'Notification' }
  & Pick<INotification, 'index' | 'severity' | 'source' | 'sticky'>
  & { actions?: Maybe<(
    { __typename?: 'NotificationActions' }
    & { primary?: Maybe<Array<Maybe<(
      { __typename?: 'Action' }
      & INotifyActionFragment
    )>>>, secondary?: Maybe<Array<Maybe<(
      { __typename?: 'Action' }
      & INotifyActionFragment
    )>>> }
  )> }
);

export type INotifyActionFragment = (
  { __typename?: 'Action' }
  & Pick<IAction, 'id' | 'label' | 'tooltip' | 'class' | 'enabled' | 'checked' | 'radio'>
);

export type IWorkspaceFolderFragment = (
  { __typename?: 'WorkspaceFolderData' }
  & Pick<IWorkspaceFolderData, 'uri' | 'name' | 'index'>
);

export type INotifyErrorMutationVariables = Exact<{
  message?: Maybe<Array<Maybe<INotificationMessageInput>> | Maybe<INotificationMessageInput>>;
}>;


export type INotifyErrorMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'notifyError'>
);

export type INotifyInfoMutationVariables = Exact<{
  message?: Maybe<Array<Maybe<INotificationMessageInput>> | Maybe<INotificationMessageInput>>;
}>;


export type INotifyInfoMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'notifyInfo'>
);

export type INotifyPromptMutationVariables = Exact<{
  severity?: Maybe<INotificationSeverity>;
  message?: Maybe<Scalars['String']>;
  choices?: Maybe<Array<Maybe<IPromptChoiceInput>> | Maybe<IPromptChoiceInput>>;
  options?: Maybe<IPromptOptionsInput>;
}>;


export type INotifyPromptMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'notifyPrompt'>
);

export type INotifyWarnMutationVariables = Exact<{
  message?: Maybe<Array<Maybe<INotificationMessageInput>> | Maybe<INotificationMessageInput>>;
}>;


export type INotifyWarnMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'notifyWarn'>
);

export type INotifyMutationVariables = Exact<{
  notification?: Maybe<INotificationInput>;
}>;


export type INotifyMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'notify'>
);

export type IUpdateWorkspaceContextAddFoldersMutationVariables = Exact<{
  foldersToAdd?: Maybe<Array<Maybe<IFoldersToAdd_Input>> | Maybe<IFoldersToAdd_Input>>;
  index?: Maybe<Scalars['Int']>;
}>;


export type IUpdateWorkspaceContextAddFoldersMutation = (
  { __typename?: 'Mutation' }
  & { updateWorkspaceContextAddFolders?: Maybe<Array<Maybe<(
    { __typename?: 'WorkspaceFolderData' }
    & Pick<IWorkspaceFolderData, 'uri' | 'name' | 'index'>
  )>>> }
);

export type IUpdateWorkspaceContextRemoveFoldersMutationVariables = Exact<{
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>> | Maybe<Scalars['URI']>>;
}>;


export type IUpdateWorkspaceContextRemoveFoldersMutation = (
  { __typename?: 'Mutation' }
  & { updateWorkspaceContextRemoveFolders?: Maybe<Array<Maybe<(
    { __typename?: 'WorkspaceFolderData' }
    & Pick<IWorkspaceFolderData, 'uri' | 'name' | 'index'>
  )>>> }
);

export type IUpdateWorkspaceContextUpdateFoldersMutationVariables = Exact<{
  foldersToAdd?: Maybe<Array<Maybe<IFoldersToAdd_Input>> | Maybe<IFoldersToAdd_Input>>;
  foldersToRemove?: Maybe<Array<Maybe<Scalars['URI']>> | Maybe<Scalars['URI']>>;
  index?: Maybe<Scalars['Int']>;
}>;


export type IUpdateWorkspaceContextUpdateFoldersMutation = (
  { __typename?: 'Mutation' }
  & { updateWorkspaceContextUpdateFolders?: Maybe<Array<Maybe<(
    { __typename?: 'WorkspaceFolderData' }
    & Pick<IWorkspaceFolderData, 'uri' | 'name' | 'index'>
  )>>> }
);

export type IGetConfiguration_WsQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetConfiguration_WsQuery = (
  { __typename?: 'Query' }
  & { getConfigurationData?: Maybe<(
    { __typename?: 'ConfigurationData' }
    & IGetConfigurationDataFragment
  )> }
);

export type IGetEnvironment_WsQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetEnvironment_WsQuery = (
  { __typename?: 'Query' }
  & { getEnvironment?: Maybe<(
    { __typename?: 'Environment' }
    & Pick<IEnvironment, 'execPath' | 'cliPath' | 'appRoot' | 'userHome' | 'userDataPath' | 'appNameLong' | 'appQuality' | 'appSettingsHome' | 'appSettingsPath' | 'appKeybindingsPath' | 'settingsSearchBuildId' | 'settingsSearchUrl' | 'globalStorageHome' | 'workspaceStorageHome' | 'backupHome' | 'backupWorkspacesPath' | 'workspacesHome' | 'workspaceSettingsPath' | 'isExtensionDevelopment' | 'disableExtensions' | 'builtinExtensionsPath' | 'extensionsPath' | 'extensionDevelopmentLocationURI' | 'extensionTestsPath' | 'logExtensionHostCommunication' | 'isBuilt' | 'wait' | 'status' | 'performance' | 'logsPath' | 'log' | 'verbose' | 'logLevel' | 'skipGettingStarted' | 'skipReleaseNotes' | 'skipAddToRecentlyOpened' | 'nodeCachedDataDir' | 'installSourcePath' | 'disableUpdates' | 'disableCrashReporter' | 'driverHandle' | 'driverVerbose'>
    & { debugExtensionHost?: Maybe<(
      { __typename?: 'ExtensionHostDebugParams' }
      & Pick<IExtensionHostDebugParams, 'port' | 'break' | 'debugId'>
    )> }
  )> }
);

export type IGetWorkspace_WsQueryVariables = Exact<{ [key: string]: never; }>;


export type IGetWorkspace_WsQuery = (
  { __typename?: 'Query' }
  & { getWorkspace?: Maybe<(
    { __typename?: 'WorkspaceData' }
    & Pick<IWorkspaceData, 'id' | 'name' | 'configuration'>
    & { folders: Array<Maybe<(
      { __typename?: 'WorkspaceFolderData' }
      & IWorkspaceFolderFragment
    )>> }
  )> }
);

export type IGetWorkspaceValue_WsQueryVariables = Exact<{
  value?: Maybe<IWorkspaceValue_Input>;
}>;


export type IGetWorkspaceValue_WsQuery = (
  { __typename?: 'Query' }
  & Pick<IQuery, 'getWorkspaceValue'>
);

export type IAddServerNotificationMutationVariables = Exact<{
  notification?: Maybe<INotificationInput>;
}>;


export type IAddServerNotificationMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'addNotification'>
);

export type IGetWorkspaceFolderContextQueryVariables = Exact<{
  arg?: Maybe<IArg_Input>;
}>;


export type IGetWorkspaceFolderContextQuery = (
  { __typename?: 'Query' }
  & { getWorkspaceFolderContext?: Maybe<(
    { __typename?: 'WorkspaceData' }
    & Pick<IWorkspaceData, 'id' | 'configuration'>
    & { folders: Array<Maybe<(
      { __typename?: 'WorkspaceFolderData' }
      & IWorkspaceFolderFragment
    )>> }
  )> }
);

export type ICodeLenseProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type ICodeLenseProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'codeLenseProviderDefinition'>
);

export type ICompletionProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type ICompletionProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'completionProviderDefinition'>
);

export type IDefinitionDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IDefinitionDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'definitionDefinition'>
);

export type IDocumentHighLightProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IDocumentHighLightProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'documentHighLightProviderDefinition'>
);

export type IDocumentFormattingProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IDocumentFormattingProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'documentFormattingProviderDefinition'>
);

export type IHoverProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IHoverProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'hoverProviderDefinition'>
);

export type IOpenLanguageDocumentMutationVariables = Exact<{
  document?: Maybe<IOpenDocumentParamsInput>;
}>;


export type IOpenLanguageDocumentMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'openLanguageDocument'>
);

export type IReferenceProviderDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IReferenceProviderDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'referenceProviderDefinition'>
);

export type IRenameDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IRenameDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'renameDefinition'>
);

export type IDocumentSymbolDefinitionMutationVariables = Exact<{
  params?: Maybe<ITextDocumentPositionParamsInput>;
}>;


export type IDocumentSymbolDefinitionMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'documentSymbolDefinition'>
);

export type IUpdateModelMutationVariables = Exact<{
  model?: Maybe<IIModelInput>;
}>;


export type IUpdateModelMutation = (
  { __typename?: 'Mutation' }
  & Pick<IMutation, 'updateModel'>
);



export type ResolverTypeWrapper<T> = Promise<T> | T;


export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};

export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
  fragment: string;
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};

export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
  selectionSet: string;
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
  | ResolverFn<TResult, TParent, TContext, TArgs>
  | ResolverWithResolve<TResult, TParent, TContext, TArgs>
  | StitchingResolver<TResult, TParent, TContext, TArgs>;

export type ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => Promise<TResult> | TResult;

export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;

export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
}

export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}

export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;

export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;

export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
  parent: TParent,
  context: TContext,
  info: GraphQLResolveInfo
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;

export type NextResolverFn<T> = () => Promise<T>;

export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
  next: NextResolverFn<TResult>,
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

/** Mapping between all available schema types and the resolvers types */
export type IResolversTypes = {
  Action: ResolverTypeWrapper<IAction>;
  String: ResolverTypeWrapper<Scalars['String']>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
  ActionInput: IActionInput;
  ActionItem: ResolverTypeWrapper<IActionItem>;
  ActionRun: ResolverTypeWrapper<IActionRun>;
  ActionRunInput: IActionRunInput;
  Actions: ResolverTypeWrapper<IActions>;
  AddEntryInput: IAddEntryInput;
  Int: ResolverTypeWrapper<Scalars['Int']>;
  AddFoldersRequest: ResolverTypeWrapper<IAddFoldersRequest>;
  AddGroupOptions_Input: IAddGroupOptions_Input;
  AdminIdeSettings: ResolverTypeWrapper<IAdminIdeSettings>;
  Anchor: ResolverTypeWrapper<IAnchor>;
  AnchorInput: IAnchorInput;
  AnyObject: ResolverTypeWrapper<Scalars['AnyObject']>;
  Arg_Input: IArg_Input;
  ArgsInput: IArgsInput;
  ArgsType: ResolverTypeWrapper<IArgsType>;
  Assets: ResolverTypeWrapper<IAssets>;
  Author: ResolverTypeWrapper<IAuthor>;
  AutoSaveConfigurationType: IAutoSaveConfigurationType;
  BaseExtension: ResolverTypeWrapper<IBaseExtension>;
  BaseResourceInput: IBaseResourceInput;
  BigInt: ResolverTypeWrapper<Scalars['BigInt']>;
  BranchStatus: ResolverTypeWrapper<IBranchStatus>;
  Bundles: ResolverTypeWrapper<IBundles>;
  CacheControlScope: ICacheControlScope;
  CachedSearchStats: ResolverTypeWrapper<ICachedSearchStats>;
  ChangeRange: ResolverTypeWrapper<IChangeRange>;
  ChangeRange_Input: IChangeRange_Input;
  ChangesChangesChunk_Input: IChangesChangesChunk_Input;
  ChangesChunk: ResolverTypeWrapper<IChangesChunk>;
  ChangesChunk_Input: IChangesChunk_Input;
  CheckboxOptions: ResolverTypeWrapper<ICheckboxOptions>;
  CheckboxOptionsInput: ICheckboxOptionsInput;
  ChunkOptions_Input: IChunkOptions_Input;
  CloseDirection: CloseDirection;
  CloseEditorOptions_Input: ICloseEditorOptions_Input;
  CloseEditor_Input: ICloseEditor_Input;
  CloseEditorsFilter: ResolverTypeWrapper<Omit<ICloseEditorsFilter, 'except'> & { except?: Maybe<IResolversTypes['EditorInput']> }>;
  CloseOptions_Input: ICloseOptions_Input;
  CodeEditorViewState: ResolverTypeWrapper<ICodeEditorViewState>;
  CodeEditorViewState_Input: ICodeEditorViewState_Input;
  CommandHandlerDescriptionType: ResolverTypeWrapper<ICommandHandlerDescriptionType>;
  CommandType: ResolverTypeWrapper<ICommandType>;
  CommandsType: ResolverTypeWrapper<ICommandsType>;
  Configuration: ResolverTypeWrapper<IConfiguration>;
  ConfigurationData: ResolverTypeWrapper<IConfigurationData>;
  ConfigurationExtensionInfo: ResolverTypeWrapper<IConfigurationExtensionInfo>;
  ConfigurationModel: ResolverTypeWrapper<IConfigurationModel>;
  ConfigurationOverrides: ResolverTypeWrapper<IConfigurationOverrides>;
  ConfigurationOverrides_Input: IConfigurationOverrides_Input;
  ConfigurationScope: ConfigurationScope;
  ConfigurationServiceAction: IConfigurationServiceAction;
  ConfigurationTarget: ConfigurationTarget;
  ContentChangedEvent: ResolverTypeWrapper<IContentChangedEvent>;
  ContentChangedEvent_Input: IContentChangedEvent_Input;
  Context: ResolverTypeWrapper<IContext>;
  ContextInput: IContextInput;
  ContextMenu: ResolverTypeWrapper<IContextMenu>;
  ContextMenuInput: IContextMenuInput;
  Contributes: ResolverTypeWrapper<IContributes>;
  CopyEditorOptions_Input: ICopyEditorOptions_Input;
  CrashReporterStartOptions: ResolverTypeWrapper<ICrashReporterStartOptions>;
  CreateFileOptions_Input: ICreateFileOptions_Input;
  CursorState: ResolverTypeWrapper<ICursorState>;
  CursorState_Input: ICursorState_Input;
  DataUriEditorInput: ResolverTypeWrapper<IDataUriEditorInput>;
  Date: ResolverTypeWrapper<Scalars['Date']>;
  DateTime: ResolverTypeWrapper<Scalars['DateTime']>;
  Debugger: ResolverTypeWrapper<IDebugger>;
  DefaultPreferencesResponse: ResolverTypeWrapper<IDefaultPreferencesResponse>;
  DefaultSettings: ResolverTypeWrapper<IDefaultSettings>;
  ID: ResolverTypeWrapper<Scalars['ID']>;
  DeleteFileOptions_Input: IDeleteFileOptions_Input;
  Detail: ResolverTypeWrapper<IDetail>;
  DetailInput: IDetailInput;
  DevToolsOptions: ResolverTypeWrapper<IDevToolsOptions>;
  DevToolsOptionsMode: IDevToolsOptionsMode;
  Dialog: ResolverTypeWrapper<IDialog>;
  DialogInput: IDialogInput;
  DialogResult: ResolverTypeWrapper<IDialogResult>;
  DiffEditorInput: ResolverTypeWrapper<Omit<IDiffEditorInput, 'originalInput' | 'modifiedInput'> & { originalInput?: Maybe<IResolversTypes['EditorInput']>, modifiedInput?: Maybe<IResolversTypes['EditorInput']> }>;
  DocSitePage: ResolverTypeWrapper<IDocSitePage>;
  DockLayout: ResolverTypeWrapper<Omit<IDockLayout, 'tabs'> & { tabs?: Maybe<Array<Maybe<IResolversTypes['EditorInput']>>> }>;
  DocumentFilter: ResolverTypeWrapper<IDocumentFilter>;
  EDITOR_ID: IEditor_Id;
  EDITOR_INPUT_ID: IEditor_Input_Id;
  EDITOR_INPUT_RESOURCE_TYPE_ID: IEditor_Input_Resource_Type_Id;
  EditKeybindingItem: ResolverTypeWrapper<IEditKeybindingItem>;
  EditorActionType: IEditorActionType;
  EditorActivation: IEditorActivation;
  EditorChildren: IResolversTypes['EditorPart'] | IResolversTypes['EditorGroup'];
  EditorChildren_Input: IEditorChildren_Input;
  EditorGroup: ResolverTypeWrapper<Omit<IEditorGroup, 'tabs'> & { tabs?: Maybe<Array<Maybe<IResolversTypes['EditorInput']>>> }>;
  EditorGroupLayout: ResolverTypeWrapper<IEditorGroupLayout>;
  EditorIdentifier: ResolverTypeWrapper<Omit<IEditorIdentifier, 'editor'> & { editor?: Maybe<IResolversTypes['EditorInput']> }>;
  EditorInput: IResolversTypes['DataUriEditorInput'] | IResolversTypes['DiffEditorInput'] | IResolversTypes['FileEditorInput'] | IResolversTypes['KeybindingEditorInput'] | IResolversTypes['PreferencesEditorInput'] | IResolversTypes['ResourceEditorInput'] | IResolversTypes['SideBySideEditorInput'] | IResolversTypes['UntitledEditorInput'];
  EditorInput_Input: IEditorInput_Input;
  EditorLayout_Input: IEditorLayout_Input;
  EditorOpenContext: IEditorOpenContext;
  EditorOpenOptions_Input: IEditorOpenOptions_Input;
  EditorOpenPositioning: EditorOpenPositioning;
  EditorOptions_Input: IEditorOptions_Input;
  EditorPart: ResolverTypeWrapper<Omit<IEditorPart, 'children'> & { children?: Maybe<Array<Maybe<IResolversTypes['EditorChildren']>>> }>;
  EditorPartConfiguration_Input: IEditorPartConfiguration_Input;
  EditorPartOptions_Input: ResolverTypeWrapper<IEditorPartOptions_Input>;
  EditorSettings: ResolverTypeWrapper<IEditorSettings>;
  EditorsOrder: EditorsOrder;
  EmptyResponse: ResolverTypeWrapper<IEmptyResponse>;
  EncodingStatus: ResolverTypeWrapper<IEncodingStatus>;
  EndOfLineSequence: ResolverTypeWrapper<IEndOfLineSequence>;
  Engines: ResolverTypeWrapper<IEngines>;
  EnterWorkspaceResult: ResolverTypeWrapper<IEnterWorkspaceResult>;
  Environment: ResolverTypeWrapper<IEnvironment>;
  EnvironmentServiceAction: IEnvironmentServiceAction;
  ExtensionColor: ResolverTypeWrapper<IExtensionColor>;
  ExtensionColorTypes: ResolverTypeWrapper<IExtensionColorTypes>;
  ExtensionConfiguration: ResolverTypeWrapper<IExtensionConfiguration>;
  ExtensionConfigurationProperty: ResolverTypeWrapper<IExtensionConfigurationProperty>;
  ExtensionContributions: ResolverTypeWrapper<IExtensionContributions>;
  ExtensionHostDebugParams: ResolverTypeWrapper<IExtensionHostDebugParams>;
  ExtensionIdentifier: ResolverTypeWrapper<IExtensionIdentifier>;
  ExtensionInstance: ResolverTypeWrapper<IExtensionInstance>;
  ExtensionJSONValidation: ResolverTypeWrapper<IExtensionJsonValidation>;
  ExtensionKind: IExtensionKind;
  ExtensionLanguage: ResolverTypeWrapper<IExtensionLanguage>;
  ExtensionManifest: ResolverTypeWrapper<IExtensionManifest>;
  ExtensionManifestBugs: ResolverTypeWrapper<IExtensionManifestBugs>;
  ExtensionManifestRepository: ResolverTypeWrapper<IExtensionManifestRepository>;
  ExtensionPackageType: ResolverTypeWrapper<IExtensionPackageType>;
  ExtensionRegistry: ResolverTypeWrapper<IExtensionRegistry>;
  ExtensionRegistryCreateExtensionResult: ResolverTypeWrapper<IExtensionRegistryCreateExtensionResult>;
  ExtensionRegistryPublishExtensionResult: ResolverTypeWrapper<IExtensionRegistryPublishExtensionResult>;
  ExtensionRegistryUpdateExtensionResult: ResolverTypeWrapper<IExtensionRegistryUpdateExtensionResult>;
  ExtensionRelease: ResolverTypeWrapper<IExtensionRelease>;
  ExtensionType: IExtensionType;
  FieldError: ResolverTypeWrapper<IFieldError>;
  FileChange: ResolverTypeWrapper<IFileChange>;
  FileChangeType: IFileChangeType;
  FileContent: ResolverTypeWrapper<IFileContent>;
  FileContentStatus: IFileContentStatus;
  FileDeleteOptions: ResolverTypeWrapper<IFileDeleteOptions>;
  FileEditorInput: ResolverTypeWrapper<IFileEditorInput>;
  FileFilter: ResolverTypeWrapper<IFileFilter>;
  FileIndexProviderStats: ResolverTypeWrapper<IFileIndexProviderStats>;
  FileLoadReason: IFileLoadReason;
  FileMatch: ResolverTypeWrapper<Omit<IFileMatch, 'results'> & { results?: Maybe<Array<Maybe<IResolversTypes['TextSearchResult']>>> }>;
  FileModelState: IFileModelState;
  FileOpenOptions: ResolverTypeWrapper<IFileOpenOptions>;
  FileOperation: IFileOperation;
  FileOperationOutput: ResolverTypeWrapper<IFileOperationOutput>;
  FileOperationResult: IFileOperationResult;
  FileOverwriteOptions: ResolverTypeWrapper<IFileOverwriteOptions>;
  FileQueryInput: IFileQueryInput;
  FileResult: ResolverTypeWrapper<IFileResult>;
  FileSearchProviderStats: ResolverTypeWrapper<IFileSearchProviderStats>;
  FileSearchStats: ResolverTypeWrapper<Omit<IFileSearchStats, 'detailStats'> & { detailStats?: Maybe<IResolversTypes['FileSearchStatsdetailStats']> }>;
  FileSearchStatsType: IFileSearchStatsType;
  FileSearchStatsdetailStats: IResolversTypes['SearchEngineStats'] | IResolversTypes['CachedSearchStats'] | IResolversTypes['FileSearchProviderStats'] | IResolversTypes['FileIndexProviderStats'];
  FileStat: ResolverTypeWrapper<IFileStat>;
  FileStatWithMetadata: ResolverTypeWrapper<IFileStatWithMetadata>;
  FileStateChange: IFileStateChange;
  FileStreamContent: ResolverTypeWrapper<IFileStreamContent>;
  FileToOpen: ResolverTypeWrapper<IFileToOpen>;
  FileType: IFileType;
  FileWriteOptions: ResolverTypeWrapper<IFileWriteOptions>;
  Files: ResolverTypeWrapper<IFiles>;
  Files_Stat: ResolverTypeWrapper<IFiles_Stat>;
  FolderConfigurationModel: ResolverTypeWrapper<IFolderConfigurationModel>;
  FolderInput: IFolderInput;
  FolderQuery: ResolverTypeWrapper<IFolderQuery>;
  FolderQueryInput: IFolderQueryInput;
  FolderSettings: ResolverTypeWrapper<IFolderSettings>;
  FolderToOpen: ResolverTypeWrapper<IFolderToOpen>;
  FoldersToAdd_Input: IFoldersToAdd_Input;
  GalleryBanner: ResolverTypeWrapper<IGalleryBanner>;
  GalleryExtension: ResolverTypeWrapper<IGalleryExtension>;
  Float: ResolverTypeWrapper<Scalars['Float']>;
  GalleryExtensionAsset: ResolverTypeWrapper<IGalleryExtensionAsset>;
  GalleryExtensionAssets: ResolverTypeWrapper<IGalleryExtensionAssets>;
  GalleryExtensionProperties: ResolverTypeWrapper<IGalleryExtensionProperties>;
  GalleryExtensionResources: ResolverTypeWrapper<IGalleryExtensionResources>;
  GalleryFilter: IGalleryFilter;
  GalleryPager: ResolverTypeWrapper<IGalleryPager>;
  GalleryQueryInput: IGalleryQueryInput;
  GeoLocation: ResolverTypeWrapper<IGeoLocation>;
  Git: ResolverTypeWrapper<IGit>;
  GitDecorations: ResolverTypeWrapper<IGitDecorations>;
  GlobalSettings: ResolverTypeWrapper<IGlobalSettings>;
  GoToLineQuickAccess: ResolverTypeWrapper<IGoToLineQuickAccess>;
  Grammar: ResolverTypeWrapper<IGrammar>;
  GraphqlCallType: IGraphqlCallType;
  GroupDirection: GroupDirection;
  GroupLayoutArgument: ResolverTypeWrapper<IGroupLayoutArgument>;
  GroupLocation: GroupLocation;
  GroupOrientation: GroupOrientation;
  GroupsArrangement: GroupsArrangement;
  GroupsOrder: GroupsOrder;
  HotExitConfiguration: IHotExitConfiguration;
  Hover: never;
  IActivationRequest: IIActivationRequest;
  IBaseStat: IResolversTypes['FileContent'] | IResolversTypes['FileStat'] | IResolversTypes['FileStatWithMetadata'] | IResolversTypes['FileStreamContent'] | IResolversTypes['TextFileContent'] | IResolversTypes['TextFilePublishContent'] | IResolversTypes['TextFileStreamContent'];
  IBaseStatWithMetadata: IResolversTypes['FileContent'] | IResolversTypes['FileStatWithMetadata'] | IResolversTypes['FileStreamContent'] | IResolversTypes['TextFileContent'] | IResolversTypes['TextFileStreamContent'];
  IBaseTextFileContent: IResolversTypes['TextFileContent'] | IResolversTypes['TextFilePublishContent'] | IResolversTypes['TextFileStreamContent'];
  IBehaviorSubject: ResolverTypeWrapper<IIBehaviorSubject>;
  IBehaviorSubjectValue: ResolverTypeWrapper<IIBehaviorSubjectValue>;
  ICommonQueryProps: never;
  IConfigurationChangeEvent: ResolverTypeWrapper<IIConfigurationChangeEvent>;
  IConfigurationService: never;
  IContentChangedEvent: IResolversTypes['FileStatWithMetadata'];
  IDebugParams: IResolversTypes['ExtensionHostDebugParams'];
  IDestinationAnonymousSubject: ResolverTypeWrapper<IIDestinationAnonymousSubject>;
  IDocumentSelector: ResolverTypeWrapper<IIDocumentSelector>;
  IEditorGroup: IResolversTypes['EditorGroup'];
  IEditorInput: IResolversTypes['DataUriEditorInput'] | IResolversTypes['DiffEditorInput'] | IResolversTypes['FileEditorInput'] | IResolversTypes['KeybindingEditorInput'] | IResolversTypes['PreferencesEditorInput'] | IResolversTypes['ResourceEditorInput'] | IResolversTypes['SideBySideEditorInput'] | IResolversTypes['UntitledEditorInput'];
  IEditorInputWithGroupFields: IResolversTypes['DataUriEditorInput'] | IResolversTypes['DiffEditorInput'] | IResolversTypes['FileEditorInput'] | IResolversTypes['KeybindingEditorInput'] | IResolversTypes['PreferencesEditorInput'] | IResolversTypes['ResourceEditorInput'] | IResolversTypes['SideBySideEditorInput'] | IResolversTypes['UntitledEditorInput'];
  IEncodingSupport: IResolversTypes['FileEditorInput'];
  IFileClientMetadata: IResolversTypes['FileStatWithMetadata'] | IResolversTypes['TextFileContent'];
  IFileEditorInput: IResolversTypes['FileEditorInput'];
  IFileMatch: IResolversTypes['FileMatch'] | IResolversTypes['SearchProgressItem'];
  IFileSystemProviderActivationEvent: never;
  IFileSystemProviderRegistrationEvent: never;
  IJSONValueInput: IIjsonValueInput;
  IModeSupport: IResolversTypes['FileEditorInput'];
  IModel: ResolverTypeWrapper<IIModel>;
  IModelInput: IIModelInput;
  IObservableResult: ResolverTypeWrapper<IIObservableResult>;
  IPathData: IResolversTypes['Path'];
  IPathsToWaitForData: IResolversTypes['PathsToWaitFor'];
  IResourceUtilizationSettings: never;
  ISearchCompleteStats: IResolversTypes['SearchComplete'];
  ISearchProgress: IResolversTypes['SearchProgressItem'];
  ISettingsSubject: IResolversTypes['DefaultSettings'] | IResolversTypes['FolderSettings'] | IResolversTypes['GlobalSettings'] | IResolversTypes['LocalUserSettings'] | IResolversTypes['MemorySettings'] | IResolversTypes['RemoteUserSettings'] | IResolversTypes['UserSettings'] | IResolversTypes['WorkspaceSettings'];
  ISideBySideEditorInput: IResolversTypes['PreferencesEditorInput'] | IResolversTypes['SideBySideEditorInput'];
  ISourceAnonymousSubject: ResolverTypeWrapper<IISourceAnonymousSubject>;
  IStaticWorkspaceData: IResolversTypes['WorkspaceData'];
  IStatusbarItem: IResolversTypes['BranchStatus'] | IResolversTypes['EncodingStatus'] | IResolversTypes['EndOfLineSequence'] | IResolversTypes['Indentation'] | IResolversTypes['LanguageMode'] | IResolversTypes['SelectionStatus'] | IResolversTypes['SyncStatus'] | IResolversTypes['Terminal'];
  ISwitchMapOperator: ResolverTypeWrapper<IISwitchMapOperator>;
  ITextDocumentIdentifier: IResolversTypes['TextDocumentIdentifier'] | IResolversTypes['TextDocumentItem'];
  ITreeItem: IResolversTypes['FileStatWithMetadata'];
  IUntitledFileValue: IResolversTypes['FileStatWithMetadata'];
  IUserPreferences: ResolverTypeWrapper<IIUserPreferences>;
  IUserSettings: ResolverTypeWrapper<IIUserSettings>;
  IViewComponentData: ResolverTypeWrapper<IIViewComponentData>;
  IViewComponentDataInput: IIViewComponentDataInput;
  IViewDescriptor: IResolversTypes['TreeViewDescriptor'] | IResolversTypes['ViewDescriptor'];
  IWorkspaceRoot: ResolverTypeWrapper<IIWorkspaceRoot>;
  IWorkspaceRootInput: IIWorkspaceRootInput;
  ImportResult: ResolverTypeWrapper<IImportResult>;
  Indentation: ResolverTypeWrapper<IIndentation>;
  InputOptions: IInputOptions;
  InputTypeDetail: ResolverTypeWrapper<IInputTypeDetail>;
  InputTypeDetailInput: IInputTypeDetailInput;
  InstalledExtension: ResolverTypeWrapper<IInstalledExtension>;
  Integrated: ResolverTypeWrapper<IIntegrated>;
  JSON: ResolverTypeWrapper<Scalars['JSON']>;
  JSONObject: ResolverTypeWrapper<Scalars['JSONObject']>;
  KeepOpen_Input: IKeepOpen_Input;
  KeyBinding: ResolverTypeWrapper<IKeyBinding>;
  KeyPathSegment: IKeyPathSegment;
  KeybindingContextMenu: ResolverTypeWrapper<IKeybindingContextMenu>;
  KeybindingEditorInput: ResolverTypeWrapper<IKeybindingEditorInput>;
  KeybindingInput: IKeybindingInput;
  KeybindingItem: ResolverTypeWrapper<IKeybindingItem>;
  KeybindingItemInput: IKeybindingItemInput;
  KeybindingSource: IKeybindingSource;
  Keybindings: ResolverTypeWrapper<IKeybindings>;
  KeyboardEventInput: IKeyboardEventInput;
  KeyboardEvent_output: ResolverTypeWrapper<IKeyboardEvent_Output>;
  LableFormatType: LableFormatType;
  LanguageMode: ResolverTypeWrapper<ILanguageMode>;
  Languages: ResolverTypeWrapper<ILanguages>;
  LineMatch: ResolverTypeWrapper<ILineMatch>;
  LineRange: ResolverTypeWrapper<ILineRange>;
  LineRangeInput: ILineRangeInput;
  LoadOptions_Input: ILoadOptions_Input;
  LocalUserSettings: ResolverTypeWrapper<ILocalUserSettings>;
  Localization: ResolverTypeWrapper<ILocalization>;
  LocalizationTranslation: ResolverTypeWrapper<ILocalizationTranslation>;
  Location: IResolversTypes['ProvideTextDocumentLocationSignature'];
  MarkupContent: never;
  MarkupKind: IMarkupKind;
  Match: ResolverTypeWrapper<IMatch>;
  MatchInput: IMatchInput;
  MemorySettings: ResolverTypeWrapper<IMemorySettings>;
  MenuId: IMenuId;
  MenuItem: ResolverTypeWrapper<IMenuItem>;
  MenuItemAction: ResolverTypeWrapper<IMenuItemAction>;
  MenuItemActionContext: ResolverTypeWrapper<IMenuItemActionContext>;
  MenuItemActionDebug: ResolverTypeWrapper<IMenuItemActionDebug>;
  MenuItemActionEditor: ResolverTypeWrapper<IMenuItemActionEditor>;
  MenuItemActionEditorTitle: ResolverTypeWrapper<IMenuItemActionEditorTitle>;
  MenuItemActionScm: ResolverTypeWrapper<IMenuItemActionScm>;
  MenuItemActionScmChange: ResolverTypeWrapper<IMenuItemActionScmChange>;
  MenuItemActionView: ResolverTypeWrapper<IMenuItemActionView>;
  MenuItemInput: IMenuItemInput;
  Menus: ResolverTypeWrapper<IMenus>;
  MergeGroupMode: MergeGroupMode;
  MergeGroupOptions_Input: IMergeGroupOptions_Input;
  MessageBoxOptions: ResolverTypeWrapper<IMessageBoxOptions>;
  MessageBoxResult: ResolverTypeWrapper<IMessageBoxResult>;
  MessageLink: ResolverTypeWrapper<IMessageLink>;
  MessageLinkInput: IMessageLinkInput;
  ModelLoadOrCreateOptions_Input: IModelLoadOrCreateOptions_Input;
  ModelLoadOrCreateOptions_Input_reload: IModelLoadOrCreateOptions_Input_Reload;
  MoleculerServiceName: IMoleculerServiceName;
  MoveEditorOptions_Input: IMoveEditorOptions_Input;
  MoveEditor_Input: IMoveEditor_Input;
  Mutation: ResolverTypeWrapper<{}>;
  NativeOpenDialogOptions: ResolverTypeWrapper<INativeOpenDialogOptions>;
  NewWindowOptions: ResolverTypeWrapper<INewWindowOptions>;
  Node: IResolversTypes['RegistryExtension'];
  Notification: ResolverTypeWrapper<INotification>;
  NotificationActions: ResolverTypeWrapper<INotificationActions>;
  NotificationActionsInput: INotificationActionsInput;
  NotificationChangeEvent: ResolverTypeWrapper<INotificationChangeEvent>;
  NotificationChangeType: INotificationChangeType;
  NotificationInput: INotificationInput;
  NotificationMessage: ResolverTypeWrapper<INotificationMessage>;
  NotificationMessageInput: INotificationMessageInput;
  NotificationSeverity: Severity;
  NotificationViewItem: ResolverTypeWrapper<INotificationViewItem>;
  NotificationViewItemLabelKind: INotificationViewItemLabelKind;
  NotificationViewItemProgress: ResolverTypeWrapper<INotificationViewItemProgress>;
  NotificationViewItemProgressState: ResolverTypeWrapper<INotificationViewItemProgressState>;
  Notifications: ResolverTypeWrapper<INotifications>;
  Observable: ResolverTypeWrapper<Scalars['Observable']>;
  OneSearchPathPattern: ResolverTypeWrapper<IOneSearchPathPattern>;
  OpenConfiguration: ResolverTypeWrapper<Omit<IOpenConfiguration, 'urisToOpen'> & { urisToOpen?: Maybe<Array<Maybe<IResolversTypes['URIToOpen']>>> }>;
  OpenContext: IOpenContext;
  OpenDialogOptions: ResolverTypeWrapper<IOpenDialogOptions>;
  OpenDialogOptionsProperties: IOpenDialogOptionsProperties;
  OpenDiff_Input: IOpenDiff_Input;
  OpenDocumentParamsInput: IOpenDocumentParamsInput;
  OpenDocumentTextParamsInput: IOpenDocumentTextParamsInput;
  OpenEditor_Input: IOpenEditor_Input;
  OpenFileRequest: ResolverTypeWrapper<IOpenFileRequest>;
  OpenPositioningType: OpenPositioningType;
  OpenSettings: ResolverTypeWrapper<IOpenSettings>;
  OpenSideBySideDirection: OpenSideBySideDirection;
  Output: ResolverTypeWrapper<IOutput>;
  Overrides: ResolverTypeWrapper<IOverrides>;
  PageInfo: ResolverTypeWrapper<IPageInfo>;
  Path: ResolverTypeWrapper<IPath>;
  PathsToWaitFor: ResolverTypeWrapper<IPathsToWaitFor>;
  PatternInfo: ResolverTypeWrapper<IPatternInfo>;
  PatternInfoInput: IPatternInfoInput;
  PendingStatusbarEntry: ResolverTypeWrapper<IPendingStatusbarEntry>;
  PickInputOptions: IPickInputOptions;
  PickItem: IPickItem;
  Position: ResolverTypeWrapper<IPosition>;
  PositionInput: IPositionInput;
  PreferenceItem: ResolverTypeWrapper<IPreferenceItem>;
  PreferencesEditorInput: ResolverTypeWrapper<Omit<IPreferencesEditorInput, 'master' | 'details'> & { master?: Maybe<IResolversTypes['EditorInput']>, details?: Maybe<IResolversTypes['EditorInput']> }>;
  PreferencesType: ResolverTypeWrapper<IPreferencesType>;
  PrimaryButtonAction: ResolverTypeWrapper<IPrimaryButtonAction>;
  PrimaryButtonActionInput: IPrimaryButtonActionInput;
  ProcessMonitoring: ResolverTypeWrapper<IProcessMonitoring>;
  Progress: ResolverTypeWrapper<IProgress>;
  PromptChoiceInput: IPromptChoiceInput;
  PromptChoiceRun: IPromptChoiceRun;
  PromptOptionsCancel: IPromptOptionsCancel;
  PromptOptionsInput: IPromptOptionsInput;
  ProvideTextDocumentLocationSignature: ResolverTypeWrapper<IProvideTextDocumentLocationSignature>;
  ProvideTextDocumentLocationSignatureInput: IProvideTextDocumentLocationSignatureInput;
  ProvidedRemoteConnectionStates: IProvidedRemoteConnectionStates;
  Query: ResolverTypeWrapper<{}>;
  QueryType: IQueryType;
  QuickInput: ResolverTypeWrapper<IQuickInput>;
  QuickInputModel: ResolverTypeWrapper<IQuickInputModel>;
  QuickPick: ResolverTypeWrapper<IQuickPick>;
  QuickPickItem: ResolverTypeWrapper<IQuickPickItem>;
  QuickPickItemHighlights: ResolverTypeWrapper<IQuickPickItemHighlights>;
  QuickPickItemHighlightsInput: IQuickPickItemHighlightsInput;
  Range: ResolverTypeWrapper<IRange>;
  RangeInput: IRangeInput;
  ReadFileOptions_Input: IReadFileOptions_Input;
  ReadFileOptions_Input_limits: IReadFileOptions_Input_Limits;
  ReadTextFileOptions_Input: IReadTextFileOptions_Input;
  ReadyState: IReadyState;
  RegistryEntry: ResolverTypeWrapper<IRegistryEntry>;
  RegistryExtension: ResolverTypeWrapper<IRegistryExtension>;
  RegistryExtensionConnection: ResolverTypeWrapper<IRegistryExtensionConnection>;
  RegistryPublisher: ResolverTypeWrapper<IRegistryPublisher>;
  RegistryPublisherConnection: ResolverTypeWrapper<IRegistryPublisherConnection>;
  RemoteUserSettings: ResolverTypeWrapper<IRemoteUserSettings>;
  RemoveEditor_Input: IRemoveEditor_Input;
  ReplaceContentResult: ResolverTypeWrapper<IReplaceContentResult>;
  ResolveAll_toResolveWithMetadata_Input: IResolveAll_ToResolveWithMetadata_Input;
  ResolveAll_toResolve_Input: IResolveAll_ToResolve_Input;
  ResolveFileOptions_Input: IResolveFileOptions_Input;
  ResolveFileResult: ResolverTypeWrapper<IResolveFileResult>;
  ResolveFileResultWithMetadata: ResolverTypeWrapper<IResolveFileResultWithMetadata>;
  ResolveMetadataFileOptions_Input: IResolveMetadataFileOptions_Input;
  ResourceDiff_Input: IResourceDiff_Input;
  ResourceEditorInput: ResolverTypeWrapper<IResourceEditorInput>;
  ResourceEncoding: ResolverTypeWrapper<IResourceEncoding>;
  ResourceMapConfigurationModel: ResolverTypeWrapper<IResourceMapConfigurationModel>;
  ResourceSideBySide_Input: IResourceSideBySide_Input;
  Resource_Input: IResource_Input;
  RevealOptions: ResolverTypeWrapper<IRevealOptions>;
  RunActionInWindowRequest: ResolverTypeWrapper<IRunActionInWindowRequest>;
  RunActionInWindowRequestFrom: IRunActionInWindowRequestFrom;
  RunKeybindingInWindowRequest: ResolverTypeWrapper<IRunKeybindingInWindowRequest>;
  STATUSBAR_ITEM_ID: IStatusbar_Item_Id;
  SaveDialogOptions: ResolverTypeWrapper<ISaveDialogOptions>;
  SaveOptions_Input: ISaveOptions_Input;
  SaveReason: ISaveReason;
  SaveWorkspaceRes: ResolverTypeWrapper<ISaveWorkspaceRes>;
  Scripts: ResolverTypeWrapper<IScripts>;
  Search: ResolverTypeWrapper<ISearch>;
  SearchComplete: ResolverTypeWrapper<Omit<ISearchComplete, 'stats'> & { stats: IResolversTypes['SearchCompleteStatsStats'] }>;
  SearchCompleteStatsStats: IResolversTypes['FileSearchStats'] | IResolversTypes['TextSearchStats'];
  SearchCompleteStream: ResolverTypeWrapper<Omit<ISearchCompleteStream, 'stats'> & { stats: IResolversTypes['SearchCompleteStatsStats'] }>;
  SearchEngineStats: ResolverTypeWrapper<ISearchEngineStats>;
  SearchLog: ResolverTypeWrapper<ISearchLog>;
  SearchPathPattern: ResolverTypeWrapper<ISearchPathPattern>;
  SearchProgressItem: ResolverTypeWrapper<Omit<ISearchProgressItem, 'results'> & { results?: Maybe<Array<Maybe<IResolversTypes['TextSearchResult']>>> }>;
  SearchQuickOpen: ResolverTypeWrapper<ISearchQuickOpen>;
  SearchRange: ResolverTypeWrapper<ISearchRange>;
  SearchStreamInput: ISearchStreamInput;
  SelectEditor_Input: ISelectEditor_Input;
  SelectedOutput: ResolverTypeWrapper<ISelectedOutput>;
  SelectionStatus: ResolverTypeWrapper<ISelectionStatus>;
  SetStatusMsgInput: ISetStatusMsgInput;
  Setting: ResolverTypeWrapper<ISetting>;
  SettingValueType: ISettingValueType;
  Settings: ResolverTypeWrapper<ISettings>;
  SettingsCascade: ResolverTypeWrapper<Omit<ISettingsCascade, 'subjects'> & { subjects?: Maybe<Array<Maybe<IResolversTypes['SettingsSubject']>>> }>;
  SettingsGroup: ResolverTypeWrapper<ISettingsGroup>;
  SettingsSection: ResolverTypeWrapper<ISettingsSection>;
  SettingsSubject: IResolversTypes['UserSettings'] | IResolversTypes['LocalUserSettings'] | IResolversTypes['RemoteUserSettings'] | IResolversTypes['FolderSettings'] | IResolversTypes['GlobalSettings'] | IResolversTypes['WorkspaceSettings'] | IResolversTypes['MemorySettings'] | IResolversTypes['DefaultSettings'];
  Shell: ResolverTypeWrapper<IShell>;
  ShellArgs: ResolverTypeWrapper<IShellArgs>;
  SideBySideEditor: SideBySideEditor;
  SideBySideEditorInput: ResolverTypeWrapper<Omit<ISideBySideEditorInput, 'master' | 'details'> & { master?: Maybe<IResolversTypes['EditorInput']>, details?: Maybe<IResolversTypes['EditorInput']> }>;
  Snippet: ResolverTypeWrapper<ISnippet>;
  Sort: ISort;
  SortEnum: ISortEnum;
  Statusbar: ResolverTypeWrapper<Omit<IStatusbar, 'items'> & { items?: Maybe<Array<Maybe<IResolversTypes['StatusbarItem']>>> }>;
  StatusbarAlignment: IStatusbarAlignment;
  StatusbarEntry: ResolverTypeWrapper<IStatusbarEntry>;
  StatusbarEntryInput: IStatusbarEntryInput;
  StatusbarItem: IResolversTypes['Terminal'] | IResolversTypes['SelectionStatus'] | IResolversTypes['Indentation'] | IResolversTypes['EncodingStatus'] | IResolversTypes['EndOfLineSequence'] | IResolversTypes['LanguageMode'] | IResolversTypes['SyncStatus'] | IResolversTypes['BranchStatus'];
  StorageScope: IStorageScope;
  StreamContent: ResolverTypeWrapper<IStreamContent>;
  Subscription: ResolverTypeWrapper<{}>;
  SyncStatus: ResolverTypeWrapper<ISyncStatus>;
  TabCloseButtonType: TabCloseButtonType;
  TabSizingType: TabSizingType;
  Terminal: ResolverTypeWrapper<ITerminal>;
  TextBufferData: ResolverTypeWrapper<ITextBufferData>;
  TextDocumentIdentifier: ResolverTypeWrapper<ITextDocumentIdentifier>;
  TextDocumentIdentifierInput: ITextDocumentIdentifierInput;
  TextDocumentItem: ResolverTypeWrapper<ITextDocumentItem>;
  TextDocumentItemInput: ITextDocumentItemInput;
  TextDocumentPositionParams: IResolversTypes['ProvideTextDocumentLocationSignature'];
  TextDocumentPositionParamsInput: ITextDocumentPositionParamsInput;
  TextDocumentRegistrationOptions: ResolverTypeWrapper<ITextDocumentRegistrationOptions>;
  TextDocumentRegistrationOptionsInput: ITextDocumentRegistrationOptionsInput;
  TextEditorOptions_Input: ITextEditorOptions_Input;
  TextEditorSelectionRevealType: ITextEditorSelectionRevealType;
  TextEditorSelection_Input: ITextEditorSelection_Input;
  TextFileContent: ResolverTypeWrapper<ITextFileContent>;
  TextFileOperationResult: ITextFileOperationResult;
  TextFilePublishContent: ResolverTypeWrapper<ITextFilePublishContent>;
  TextFileStreamContent: ResolverTypeWrapper<ITextFileStreamContent>;
  TextQueryInput: ITextQueryInput;
  TextSearchContext: ResolverTypeWrapper<ITextSearchContext>;
  TextSearchMatch: ResolverTypeWrapper<ITextSearchMatch>;
  TextSearchPreviewOptions: ResolverTypeWrapper<ITextSearchPreviewOptions>;
  TextSearchPreviewOptionsInput: ITextSearchPreviewOptionsInput;
  TextSearchResult: IResolversTypes['TextSearchMatch'] | IResolversTypes['TextSearchContext'];
  TextSearchResultPreview: ResolverTypeWrapper<ITextSearchResultPreview>;
  TextSearchStats: ResolverTypeWrapper<ITextSearchStats>;
  TextSearchStatsType: ITextSearchStatsType;
  ThemeLabel: ResolverTypeWrapper<IThemeLabel>;
  Time: ResolverTypeWrapper<Scalars['Time']>;
  TreeData_Input: ITreeData_Input;
  TreeItem: ResolverTypeWrapper<ITreeItem>;
  TreeItemCollapsibleState: ITreeItemCollapsibleState;
  TreeViewDescriptor: ResolverTypeWrapper<ITreeViewDescriptor>;
  URI: ResolverTypeWrapper<Scalars['URI']>;
  URIInput: ResolverTypeWrapper<Scalars['URIInput']>;
  URIToOpen: IResolversTypes['WorkspaceToOpen'] | IResolversTypes['FolderToOpen'] | IResolversTypes['FileToOpen'];
  UntitledEditorInput: ResolverTypeWrapper<IUntitledEditorInput>;
  UntitledResource_Input: IUntitledResource_Input;
  UpdateDelayedResource: ResolverTypeWrapper<IUpdateDelayedResource>;
  UpdateEntryInput: IUpdateEntryInput;
  UpdatedResource: ResolverTypeWrapper<IUpdatedResource>;
  UserPreferencesRes: ResolverTypeWrapper<IUserPreferencesRes>;
  UserSettings: ResolverTypeWrapper<IUserSettings>;
  VSBuffer: ResolverTypeWrapper<Scalars['VSBuffer']>;
  VSBufferReadableStream: ResolverTypeWrapper<Scalars['VSBufferReadableStream']>;
  View: ResolverTypeWrapper<IView>;
  ViewContainer: ResolverTypeWrapper<IViewContainer>;
  ViewDescriptor: ResolverTypeWrapper<IViewDescriptor>;
  ViewState: ResolverTypeWrapper<IViewState>;
  ViewState_Input: IViewState_Input;
  WatchOptions_Input: IWatchOptions_Input;
  WindowConfiguration: ResolverTypeWrapper<IWindowConfiguration>;
  WorkspaceContextServiceAction: IWorkspaceContextServiceAction;
  WorkspaceData: ResolverTypeWrapper<IWorkspaceData>;
  WorkspaceFolderData: ResolverTypeWrapper<IWorkspaceFolderData>;
  WorkspaceIdentifier: ResolverTypeWrapper<IWorkspaceIdentifier>;
  WorkspacePreferenceActivityBar: ResolverTypeWrapper<IWorkspacePreferenceActivityBar>;
  WorkspacePreferenceCommandPalette: ResolverTypeWrapper<IWorkspacePreferenceCommandPalette>;
  WorkspacePreferenceEditor: ResolverTypeWrapper<IWorkspacePreferenceEditor>;
  WorkspacePreferenceExperimental: ResolverTypeWrapper<IWorkspacePreferenceExperimental>;
  WorkspacePreferenceList: ResolverTypeWrapper<IWorkspacePreferenceList>;
  WorkspacePreferencePanel: ResolverTypeWrapper<IWorkspacePreferencePanel>;
  WorkspacePreferenceQuickOpen: ResolverTypeWrapper<IWorkspacePreferenceQuickOpen>;
  WorkspacePreferenceSettings: ResolverTypeWrapper<IWorkspacePreferenceSettings>;
  WorkspacePreferenceSideBar: ResolverTypeWrapper<IWorkspacePreferenceSideBar>;
  WorkspacePreferenceStatusBar: ResolverTypeWrapper<IWorkspacePreferenceStatusBar>;
  WorkspacePreferenceTips: ResolverTypeWrapper<IWorkspacePreferenceTips>;
  WorkspacePreferenceView: ResolverTypeWrapper<IWorkspacePreferenceView>;
  WorkspacePreferenceWorkbench: ResolverTypeWrapper<IWorkspacePreferenceWorkbench>;
  WorkspaceRes: ResolverTypeWrapper<IWorkspaceRes>;
  WorkspaceSettings: ResolverTypeWrapper<IWorkspaceSettings>;
  WorkspaceToOpen: ResolverTypeWrapper<IWorkspaceToOpen>;
  WorkspaceValue_Input: IWorkspaceValue_Input;
  WriteFileOptions_Input: IWriteFileOptions_Input;
  WriteTextFileOptions_Input: IWriteTextFileOptions_Input;
  commentThread: ICommentThread;
  scmProviders: IScmProviders;
  scmResourceGroups: IScmResourceGroups;
};

/** Mapping between all available schema types and the resolvers parents */
export type IResolversParentTypes = {
  Action: IAction;
  String: Scalars['String'];
  Boolean: Scalars['Boolean'];
  ActionInput: IActionInput;
  ActionItem: IActionItem;
  ActionRun: IActionRun;
  ActionRunInput: IActionRunInput;
  Actions: IActions;
  AddEntryInput: IAddEntryInput;
  Int: Scalars['Int'];
  AddFoldersRequest: IAddFoldersRequest;
  AddGroupOptions_Input: IAddGroupOptions_Input;
  AdminIdeSettings: IAdminIdeSettings;
  Anchor: IAnchor;
  AnchorInput: IAnchorInput;
  AnyObject: Scalars['AnyObject'];
  Arg_Input: IArg_Input;
  ArgsInput: IArgsInput;
  ArgsType: IArgsType;
  Assets: IAssets;
  Author: IAuthor;
  BaseExtension: IBaseExtension;
  BaseResourceInput: IBaseResourceInput;
  BigInt: Scalars['BigInt'];
  BranchStatus: IBranchStatus;
  Bundles: IBundles;
  CachedSearchStats: ICachedSearchStats;
  ChangeRange: IChangeRange;
  ChangeRange_Input: IChangeRange_Input;
  ChangesChangesChunk_Input: IChangesChangesChunk_Input;
  ChangesChunk: IChangesChunk;
  ChangesChunk_Input: IChangesChunk_Input;
  CheckboxOptions: ICheckboxOptions;
  CheckboxOptionsInput: ICheckboxOptionsInput;
  ChunkOptions_Input: IChunkOptions_Input;
  CloseEditorOptions_Input: ICloseEditorOptions_Input;
  CloseEditor_Input: ICloseEditor_Input;
  CloseEditorsFilter: Omit<ICloseEditorsFilter, 'except'> & { except?: Maybe<IResolversParentTypes['EditorInput']> };
  CloseOptions_Input: ICloseOptions_Input;
  CodeEditorViewState: ICodeEditorViewState;
  CodeEditorViewState_Input: ICodeEditorViewState_Input;
  CommandHandlerDescriptionType: ICommandHandlerDescriptionType;
  CommandType: ICommandType;
  CommandsType: ICommandsType;
  Configuration: IConfiguration;
  ConfigurationData: IConfigurationData;
  ConfigurationExtensionInfo: IConfigurationExtensionInfo;
  ConfigurationModel: IConfigurationModel;
  ConfigurationOverrides: IConfigurationOverrides;
  ConfigurationOverrides_Input: IConfigurationOverrides_Input;
  ContentChangedEvent: IContentChangedEvent;
  ContentChangedEvent_Input: IContentChangedEvent_Input;
  Context: IContext;
  ContextInput: IContextInput;
  ContextMenu: IContextMenu;
  ContextMenuInput: IContextMenuInput;
  Contributes: IContributes;
  CopyEditorOptions_Input: ICopyEditorOptions_Input;
  CrashReporterStartOptions: ICrashReporterStartOptions;
  CreateFileOptions_Input: ICreateFileOptions_Input;
  CursorState: ICursorState;
  CursorState_Input: ICursorState_Input;
  DataUriEditorInput: IDataUriEditorInput;
  Date: Scalars['Date'];
  DateTime: Scalars['DateTime'];
  Debugger: IDebugger;
  DefaultPreferencesResponse: IDefaultPreferencesResponse;
  DefaultSettings: IDefaultSettings;
  ID: Scalars['ID'];
  DeleteFileOptions_Input: IDeleteFileOptions_Input;
  Detail: IDetail;
  DetailInput: IDetailInput;
  DevToolsOptions: IDevToolsOptions;
  Dialog: IDialog;
  DialogInput: IDialogInput;
  DialogResult: IDialogResult;
  DiffEditorInput: Omit<IDiffEditorInput, 'originalInput' | 'modifiedInput'> & { originalInput?: Maybe<IResolversParentTypes['EditorInput']>, modifiedInput?: Maybe<IResolversParentTypes['EditorInput']> };
  DocSitePage: IDocSitePage;
  DockLayout: Omit<IDockLayout, 'tabs'> & { tabs?: Maybe<Array<Maybe<IResolversParentTypes['EditorInput']>>> };
  DocumentFilter: IDocumentFilter;
  EditKeybindingItem: IEditKeybindingItem;
  EditorChildren: IResolversParentTypes['EditorPart'] | IResolversParentTypes['EditorGroup'];
  EditorChildren_Input: IEditorChildren_Input;
  EditorGroup: Omit<IEditorGroup, 'tabs'> & { tabs?: Maybe<Array<Maybe<IResolversParentTypes['EditorInput']>>> };
  EditorGroupLayout: IEditorGroupLayout;
  EditorIdentifier: Omit<IEditorIdentifier, 'editor'> & { editor?: Maybe<IResolversParentTypes['EditorInput']> };
  EditorInput: IResolversParentTypes['DataUriEditorInput'] | IResolversParentTypes['DiffEditorInput'] | IResolversParentTypes['FileEditorInput'] | IResolversParentTypes['KeybindingEditorInput'] | IResolversParentTypes['PreferencesEditorInput'] | IResolversParentTypes['ResourceEditorInput'] | IResolversParentTypes['SideBySideEditorInput'] | IResolversParentTypes['UntitledEditorInput'];
  EditorInput_Input: IEditorInput_Input;
  EditorLayout_Input: IEditorLayout_Input;
  EditorOpenOptions_Input: IEditorOpenOptions_Input;
  EditorOptions_Input: IEditorOptions_Input;
  EditorPart: Omit<IEditorPart, 'children'> & { children?: Maybe<Array<Maybe<IResolversParentTypes['EditorChildren']>>> };
  EditorPartConfiguration_Input: IEditorPartConfiguration_Input;
  EditorPartOptions_Input: IEditorPartOptions_Input;
  EditorSettings: IEditorSettings;
  EmptyResponse: IEmptyResponse;
  EncodingStatus: IEncodingStatus;
  EndOfLineSequence: IEndOfLineSequence;
  Engines: IEngines;
  EnterWorkspaceResult: IEnterWorkspaceResult;
  Environment: IEnvironment;
  ExtensionColor: IExtensionColor;
  ExtensionColorTypes: IExtensionColorTypes;
  ExtensionConfiguration: IExtensionConfiguration;
  ExtensionConfigurationProperty: IExtensionConfigurationProperty;
  ExtensionContributions: IExtensionContributions;
  ExtensionHostDebugParams: IExtensionHostDebugParams;
  ExtensionIdentifier: IExtensionIdentifier;
  ExtensionInstance: IExtensionInstance;
  ExtensionJSONValidation: IExtensionJsonValidation;
  ExtensionLanguage: IExtensionLanguage;
  ExtensionManifest: IExtensionManifest;
  ExtensionManifestBugs: IExtensionManifestBugs;
  ExtensionManifestRepository: IExtensionManifestRepository;
  ExtensionPackageType: IExtensionPackageType;
  ExtensionRegistry: IExtensionRegistry;
  ExtensionRegistryCreateExtensionResult: IExtensionRegistryCreateExtensionResult;
  ExtensionRegistryPublishExtensionResult: IExtensionRegistryPublishExtensionResult;
  ExtensionRegistryUpdateExtensionResult: IExtensionRegistryUpdateExtensionResult;
  ExtensionRelease: IExtensionRelease;
  FieldError: IFieldError;
  FileChange: IFileChange;
  FileContent: IFileContent;
  FileDeleteOptions: IFileDeleteOptions;
  FileEditorInput: IFileEditorInput;
  FileFilter: IFileFilter;
  FileIndexProviderStats: IFileIndexProviderStats;
  FileMatch: Omit<IFileMatch, 'results'> & { results?: Maybe<Array<Maybe<IResolversParentTypes['TextSearchResult']>>> };
  FileOpenOptions: IFileOpenOptions;
  FileOperationOutput: IFileOperationOutput;
  FileOverwriteOptions: IFileOverwriteOptions;
  FileQueryInput: IFileQueryInput;
  FileResult: IFileResult;
  FileSearchProviderStats: IFileSearchProviderStats;
  FileSearchStats: Omit<IFileSearchStats, 'detailStats'> & { detailStats?: Maybe<IResolversParentTypes['FileSearchStatsdetailStats']> };
  FileSearchStatsdetailStats: IResolversParentTypes['SearchEngineStats'] | IResolversParentTypes['CachedSearchStats'] | IResolversParentTypes['FileSearchProviderStats'] | IResolversParentTypes['FileIndexProviderStats'];
  FileStat: IFileStat;
  FileStatWithMetadata: IFileStatWithMetadata;
  FileStreamContent: IFileStreamContent;
  FileToOpen: IFileToOpen;
  FileWriteOptions: IFileWriteOptions;
  Files: IFiles;
  Files_Stat: IFiles_Stat;
  FolderConfigurationModel: IFolderConfigurationModel;
  FolderInput: IFolderInput;
  FolderQuery: IFolderQuery;
  FolderQueryInput: IFolderQueryInput;
  FolderSettings: IFolderSettings;
  FolderToOpen: IFolderToOpen;
  FoldersToAdd_Input: IFoldersToAdd_Input;
  GalleryBanner: IGalleryBanner;
  GalleryExtension: IGalleryExtension;
  Float: Scalars['Float'];
  GalleryExtensionAsset: IGalleryExtensionAsset;
  GalleryExtensionAssets: IGalleryExtensionAssets;
  GalleryExtensionProperties: IGalleryExtensionProperties;
  GalleryExtensionResources: IGalleryExtensionResources;
  GalleryFilter: IGalleryFilter;
  GalleryPager: IGalleryPager;
  GalleryQueryInput: IGalleryQueryInput;
  GeoLocation: IGeoLocation;
  Git: IGit;
  GitDecorations: IGitDecorations;
  GlobalSettings: IGlobalSettings;
  GoToLineQuickAccess: IGoToLineQuickAccess;
  Grammar: IGrammar;
  GroupLayoutArgument: IGroupLayoutArgument;
  Hover: never;
  IActivationRequest: IIActivationRequest;
  IBaseStat: IResolversParentTypes['FileContent'] | IResolversParentTypes['FileStat'] | IResolversParentTypes['FileStatWithMetadata'] | IResolversParentTypes['FileStreamContent'] | IResolversParentTypes['TextFileContent'] | IResolversParentTypes['TextFilePublishContent'] | IResolversParentTypes['TextFileStreamContent'];
  IBaseStatWithMetadata: IResolversParentTypes['FileContent'] | IResolversParentTypes['FileStatWithMetadata'] | IResolversParentTypes['FileStreamContent'] | IResolversParentTypes['TextFileContent'] | IResolversParentTypes['TextFileStreamContent'];
  IBaseTextFileContent: IResolversParentTypes['TextFileContent'] | IResolversParentTypes['TextFilePublishContent'] | IResolversParentTypes['TextFileStreamContent'];
  IBehaviorSubject: IIBehaviorSubject;
  IBehaviorSubjectValue: IIBehaviorSubjectValue;
  ICommonQueryProps: never;
  IConfigurationChangeEvent: IIConfigurationChangeEvent;
  IConfigurationService: never;
  IContentChangedEvent: IResolversParentTypes['FileStatWithMetadata'];
  IDebugParams: IResolversParentTypes['ExtensionHostDebugParams'];
  IDestinationAnonymousSubject: IIDestinationAnonymousSubject;
  IDocumentSelector: IIDocumentSelector;
  IEditorGroup: IResolversParentTypes['EditorGroup'];
  IEditorInput: IResolversParentTypes['DataUriEditorInput'] | IResolversParentTypes['DiffEditorInput'] | IResolversParentTypes['FileEditorInput'] | IResolversParentTypes['KeybindingEditorInput'] | IResolversParentTypes['PreferencesEditorInput'] | IResolversParentTypes['ResourceEditorInput'] | IResolversParentTypes['SideBySideEditorInput'] | IResolversParentTypes['UntitledEditorInput'];
  IEditorInputWithGroupFields: IResolversParentTypes['DataUriEditorInput'] | IResolversParentTypes['DiffEditorInput'] | IResolversParentTypes['FileEditorInput'] | IResolversParentTypes['KeybindingEditorInput'] | IResolversParentTypes['PreferencesEditorInput'] | IResolversParentTypes['ResourceEditorInput'] | IResolversParentTypes['SideBySideEditorInput'] | IResolversParentTypes['UntitledEditorInput'];
  IEncodingSupport: IResolversParentTypes['FileEditorInput'];
  IFileClientMetadata: IResolversParentTypes['FileStatWithMetadata'] | IResolversParentTypes['TextFileContent'];
  IFileEditorInput: IResolversParentTypes['FileEditorInput'];
  IFileMatch: IResolversParentTypes['FileMatch'] | IResolversParentTypes['SearchProgressItem'];
  IFileSystemProviderActivationEvent: never;
  IFileSystemProviderRegistrationEvent: never;
  IJSONValueInput: IIjsonValueInput;
  IModeSupport: IResolversParentTypes['FileEditorInput'];
  IModel: IIModel;
  IModelInput: IIModelInput;
  IObservableResult: IIObservableResult;
  IPathData: IResolversParentTypes['Path'];
  IPathsToWaitForData: IResolversParentTypes['PathsToWaitFor'];
  IResourceUtilizationSettings: never;
  ISearchCompleteStats: IResolversParentTypes['SearchComplete'];
  ISearchProgress: IResolversParentTypes['SearchProgressItem'];
  ISettingsSubject: IResolversParentTypes['DefaultSettings'] | IResolversParentTypes['FolderSettings'] | IResolversParentTypes['GlobalSettings'] | IResolversParentTypes['LocalUserSettings'] | IResolversParentTypes['MemorySettings'] | IResolversParentTypes['RemoteUserSettings'] | IResolversParentTypes['UserSettings'] | IResolversParentTypes['WorkspaceSettings'];
  ISideBySideEditorInput: IResolversParentTypes['PreferencesEditorInput'] | IResolversParentTypes['SideBySideEditorInput'];
  ISourceAnonymousSubject: IISourceAnonymousSubject;
  IStaticWorkspaceData: IResolversParentTypes['WorkspaceData'];
  IStatusbarItem: IResolversParentTypes['BranchStatus'] | IResolversParentTypes['EncodingStatus'] | IResolversParentTypes['EndOfLineSequence'] | IResolversParentTypes['Indentation'] | IResolversParentTypes['LanguageMode'] | IResolversParentTypes['SelectionStatus'] | IResolversParentTypes['SyncStatus'] | IResolversParentTypes['Terminal'];
  ISwitchMapOperator: IISwitchMapOperator;
  ITextDocumentIdentifier: IResolversParentTypes['TextDocumentIdentifier'] | IResolversParentTypes['TextDocumentItem'];
  ITreeItem: IResolversParentTypes['FileStatWithMetadata'];
  IUntitledFileValue: IResolversParentTypes['FileStatWithMetadata'];
  IUserPreferences: IIUserPreferences;
  IUserSettings: IIUserSettings;
  IViewComponentData: IIViewComponentData;
  IViewComponentDataInput: IIViewComponentDataInput;
  IViewDescriptor: IResolversParentTypes['TreeViewDescriptor'] | IResolversParentTypes['ViewDescriptor'];
  IWorkspaceRoot: IIWorkspaceRoot;
  IWorkspaceRootInput: IIWorkspaceRootInput;
  ImportResult: IImportResult;
  Indentation: IIndentation;
  InputOptions: IInputOptions;
  InputTypeDetail: IInputTypeDetail;
  InputTypeDetailInput: IInputTypeDetailInput;
  InstalledExtension: IInstalledExtension;
  Integrated: IIntegrated;
  JSON: Scalars['JSON'];
  JSONObject: Scalars['JSONObject'];
  KeepOpen_Input: IKeepOpen_Input;
  KeyBinding: IKeyBinding;
  KeyPathSegment: IKeyPathSegment;
  KeybindingContextMenu: IKeybindingContextMenu;
  KeybindingEditorInput: IKeybindingEditorInput;
  KeybindingInput: IKeybindingInput;
  KeybindingItem: IKeybindingItem;
  KeybindingItemInput: IKeybindingItemInput;
  Keybindings: IKeybindings;
  KeyboardEventInput: IKeyboardEventInput;
  KeyboardEvent_output: IKeyboardEvent_Output;
  LanguageMode: ILanguageMode;
  Languages: ILanguages;
  LineMatch: ILineMatch;
  LineRange: ILineRange;
  LineRangeInput: ILineRangeInput;
  LoadOptions_Input: ILoadOptions_Input;
  LocalUserSettings: ILocalUserSettings;
  Localization: ILocalization;
  LocalizationTranslation: ILocalizationTranslation;
  Location: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
  MarkupContent: never;
  Match: IMatch;
  MatchInput: IMatchInput;
  MemorySettings: IMemorySettings;
  MenuItem: IMenuItem;
  MenuItemAction: IMenuItemAction;
  MenuItemActionContext: IMenuItemActionContext;
  MenuItemActionDebug: IMenuItemActionDebug;
  MenuItemActionEditor: IMenuItemActionEditor;
  MenuItemActionEditorTitle: IMenuItemActionEditorTitle;
  MenuItemActionScm: IMenuItemActionScm;
  MenuItemActionScmChange: IMenuItemActionScmChange;
  MenuItemActionView: IMenuItemActionView;
  MenuItemInput: IMenuItemInput;
  Menus: IMenus;
  MergeGroupOptions_Input: IMergeGroupOptions_Input;
  MessageBoxOptions: IMessageBoxOptions;
  MessageBoxResult: IMessageBoxResult;
  MessageLink: IMessageLink;
  MessageLinkInput: IMessageLinkInput;
  ModelLoadOrCreateOptions_Input: IModelLoadOrCreateOptions_Input;
  ModelLoadOrCreateOptions_Input_reload: IModelLoadOrCreateOptions_Input_Reload;
  MoveEditorOptions_Input: IMoveEditorOptions_Input;
  MoveEditor_Input: IMoveEditor_Input;
  Mutation: {};
  NativeOpenDialogOptions: INativeOpenDialogOptions;
  NewWindowOptions: INewWindowOptions;
  Node: IResolversParentTypes['RegistryExtension'];
  Notification: INotification;
  NotificationActions: INotificationActions;
  NotificationActionsInput: INotificationActionsInput;
  NotificationChangeEvent: INotificationChangeEvent;
  NotificationInput: INotificationInput;
  NotificationMessage: INotificationMessage;
  NotificationMessageInput: INotificationMessageInput;
  NotificationViewItem: INotificationViewItem;
  NotificationViewItemProgress: INotificationViewItemProgress;
  NotificationViewItemProgressState: INotificationViewItemProgressState;
  Notifications: INotifications;
  Observable: Scalars['Observable'];
  OneSearchPathPattern: IOneSearchPathPattern;
  OpenConfiguration: Omit<IOpenConfiguration, 'urisToOpen'> & { urisToOpen?: Maybe<Array<Maybe<IResolversParentTypes['URIToOpen']>>> };
  OpenDialogOptions: IOpenDialogOptions;
  OpenDiff_Input: IOpenDiff_Input;
  OpenDocumentParamsInput: IOpenDocumentParamsInput;
  OpenDocumentTextParamsInput: IOpenDocumentTextParamsInput;
  OpenEditor_Input: IOpenEditor_Input;
  OpenFileRequest: IOpenFileRequest;
  OpenSettings: IOpenSettings;
  Output: IOutput;
  Overrides: IOverrides;
  PageInfo: IPageInfo;
  Path: IPath;
  PathsToWaitFor: IPathsToWaitFor;
  PatternInfo: IPatternInfo;
  PatternInfoInput: IPatternInfoInput;
  PendingStatusbarEntry: IPendingStatusbarEntry;
  PickInputOptions: IPickInputOptions;
  PickItem: IPickItem;
  Position: IPosition;
  PositionInput: IPositionInput;
  PreferenceItem: IPreferenceItem;
  PreferencesEditorInput: Omit<IPreferencesEditorInput, 'master' | 'details'> & { master?: Maybe<IResolversParentTypes['EditorInput']>, details?: Maybe<IResolversParentTypes['EditorInput']> };
  PreferencesType: IPreferencesType;
  PrimaryButtonAction: IPrimaryButtonAction;
  PrimaryButtonActionInput: IPrimaryButtonActionInput;
  ProcessMonitoring: IProcessMonitoring;
  Progress: IProgress;
  PromptChoiceInput: IPromptChoiceInput;
  PromptChoiceRun: IPromptChoiceRun;
  PromptOptionsCancel: IPromptOptionsCancel;
  PromptOptionsInput: IPromptOptionsInput;
  ProvideTextDocumentLocationSignature: IProvideTextDocumentLocationSignature;
  ProvideTextDocumentLocationSignatureInput: IProvideTextDocumentLocationSignatureInput;
  Query: {};
  QuickInput: IQuickInput;
  QuickInputModel: IQuickInputModel;
  QuickPick: IQuickPick;
  QuickPickItem: IQuickPickItem;
  QuickPickItemHighlights: IQuickPickItemHighlights;
  QuickPickItemHighlightsInput: IQuickPickItemHighlightsInput;
  Range: IRange;
  RangeInput: IRangeInput;
  ReadFileOptions_Input: IReadFileOptions_Input;
  ReadFileOptions_Input_limits: IReadFileOptions_Input_Limits;
  ReadTextFileOptions_Input: IReadTextFileOptions_Input;
  RegistryEntry: IRegistryEntry;
  RegistryExtension: IRegistryExtension;
  RegistryExtensionConnection: IRegistryExtensionConnection;
  RegistryPublisher: IRegistryPublisher;
  RegistryPublisherConnection: IRegistryPublisherConnection;
  RemoteUserSettings: IRemoteUserSettings;
  RemoveEditor_Input: IRemoveEditor_Input;
  ReplaceContentResult: IReplaceContentResult;
  ResolveAll_toResolveWithMetadata_Input: IResolveAll_ToResolveWithMetadata_Input;
  ResolveAll_toResolve_Input: IResolveAll_ToResolve_Input;
  ResolveFileOptions_Input: IResolveFileOptions_Input;
  ResolveFileResult: IResolveFileResult;
  ResolveFileResultWithMetadata: IResolveFileResultWithMetadata;
  ResolveMetadataFileOptions_Input: IResolveMetadataFileOptions_Input;
  ResourceDiff_Input: IResourceDiff_Input;
  ResourceEditorInput: IResourceEditorInput;
  ResourceEncoding: IResourceEncoding;
  ResourceMapConfigurationModel: IResourceMapConfigurationModel;
  ResourceSideBySide_Input: IResourceSideBySide_Input;
  Resource_Input: IResource_Input;
  RevealOptions: IRevealOptions;
  RunActionInWindowRequest: IRunActionInWindowRequest;
  RunKeybindingInWindowRequest: IRunKeybindingInWindowRequest;
  SaveDialogOptions: ISaveDialogOptions;
  SaveOptions_Input: ISaveOptions_Input;
  SaveWorkspaceRes: ISaveWorkspaceRes;
  Scripts: IScripts;
  Search: ISearch;
  SearchComplete: Omit<ISearchComplete, 'stats'> & { stats: IResolversParentTypes['SearchCompleteStatsStats'] };
  SearchCompleteStatsStats: IResolversParentTypes['FileSearchStats'] | IResolversParentTypes['TextSearchStats'];
  SearchCompleteStream: Omit<ISearchCompleteStream, 'stats'> & { stats: IResolversParentTypes['SearchCompleteStatsStats'] };
  SearchEngineStats: ISearchEngineStats;
  SearchLog: ISearchLog;
  SearchPathPattern: ISearchPathPattern;
  SearchProgressItem: Omit<ISearchProgressItem, 'results'> & { results?: Maybe<Array<Maybe<IResolversParentTypes['TextSearchResult']>>> };
  SearchQuickOpen: ISearchQuickOpen;
  SearchRange: ISearchRange;
  SearchStreamInput: ISearchStreamInput;
  SelectEditor_Input: ISelectEditor_Input;
  SelectedOutput: ISelectedOutput;
  SelectionStatus: ISelectionStatus;
  SetStatusMsgInput: ISetStatusMsgInput;
  Setting: ISetting;
  Settings: ISettings;
  SettingsCascade: Omit<ISettingsCascade, 'subjects'> & { subjects?: Maybe<Array<Maybe<IResolversParentTypes['SettingsSubject']>>> };
  SettingsGroup: ISettingsGroup;
  SettingsSection: ISettingsSection;
  SettingsSubject: IResolversParentTypes['UserSettings'] | IResolversParentTypes['LocalUserSettings'] | IResolversParentTypes['RemoteUserSettings'] | IResolversParentTypes['FolderSettings'] | IResolversParentTypes['GlobalSettings'] | IResolversParentTypes['WorkspaceSettings'] | IResolversParentTypes['MemorySettings'] | IResolversParentTypes['DefaultSettings'];
  Shell: IShell;
  ShellArgs: IShellArgs;
  SideBySideEditorInput: Omit<ISideBySideEditorInput, 'master' | 'details'> & { master?: Maybe<IResolversParentTypes['EditorInput']>, details?: Maybe<IResolversParentTypes['EditorInput']> };
  Snippet: ISnippet;
  Sort: ISort;
  Statusbar: Omit<IStatusbar, 'items'> & { items?: Maybe<Array<Maybe<IResolversParentTypes['StatusbarItem']>>> };
  StatusbarEntry: IStatusbarEntry;
  StatusbarEntryInput: IStatusbarEntryInput;
  StatusbarItem: IResolversParentTypes['Terminal'] | IResolversParentTypes['SelectionStatus'] | IResolversParentTypes['Indentation'] | IResolversParentTypes['EncodingStatus'] | IResolversParentTypes['EndOfLineSequence'] | IResolversParentTypes['LanguageMode'] | IResolversParentTypes['SyncStatus'] | IResolversParentTypes['BranchStatus'];
  StreamContent: IStreamContent;
  Subscription: {};
  SyncStatus: ISyncStatus;
  Terminal: ITerminal;
  TextBufferData: ITextBufferData;
  TextDocumentIdentifier: ITextDocumentIdentifier;
  TextDocumentIdentifierInput: ITextDocumentIdentifierInput;
  TextDocumentItem: ITextDocumentItem;
  TextDocumentItemInput: ITextDocumentItemInput;
  TextDocumentPositionParams: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
  TextDocumentPositionParamsInput: ITextDocumentPositionParamsInput;
  TextDocumentRegistrationOptions: ITextDocumentRegistrationOptions;
  TextDocumentRegistrationOptionsInput: ITextDocumentRegistrationOptionsInput;
  TextEditorOptions_Input: ITextEditorOptions_Input;
  TextEditorSelection_Input: ITextEditorSelection_Input;
  TextFileContent: ITextFileContent;
  TextFilePublishContent: ITextFilePublishContent;
  TextFileStreamContent: ITextFileStreamContent;
  TextQueryInput: ITextQueryInput;
  TextSearchContext: ITextSearchContext;
  TextSearchMatch: ITextSearchMatch;
  TextSearchPreviewOptions: ITextSearchPreviewOptions;
  TextSearchPreviewOptionsInput: ITextSearchPreviewOptionsInput;
  TextSearchResult: IResolversParentTypes['TextSearchMatch'] | IResolversParentTypes['TextSearchContext'];
  TextSearchResultPreview: ITextSearchResultPreview;
  TextSearchStats: ITextSearchStats;
  ThemeLabel: IThemeLabel;
  Time: Scalars['Time'];
  TreeData_Input: ITreeData_Input;
  TreeItem: ITreeItem;
  TreeViewDescriptor: ITreeViewDescriptor;
  URI: Scalars['URI'];
  URIInput: Scalars['URIInput'];
  URIToOpen: IResolversParentTypes['WorkspaceToOpen'] | IResolversParentTypes['FolderToOpen'] | IResolversParentTypes['FileToOpen'];
  UntitledEditorInput: IUntitledEditorInput;
  UntitledResource_Input: IUntitledResource_Input;
  UpdateDelayedResource: IUpdateDelayedResource;
  UpdateEntryInput: IUpdateEntryInput;
  UpdatedResource: IUpdatedResource;
  UserPreferencesRes: IUserPreferencesRes;
  UserSettings: IUserSettings;
  VSBuffer: Scalars['VSBuffer'];
  VSBufferReadableStream: Scalars['VSBufferReadableStream'];
  View: IView;
  ViewContainer: IViewContainer;
  ViewDescriptor: IViewDescriptor;
  ViewState: IViewState;
  ViewState_Input: IViewState_Input;
  WatchOptions_Input: IWatchOptions_Input;
  WindowConfiguration: IWindowConfiguration;
  WorkspaceData: IWorkspaceData;
  WorkspaceFolderData: IWorkspaceFolderData;
  WorkspaceIdentifier: IWorkspaceIdentifier;
  WorkspacePreferenceActivityBar: IWorkspacePreferenceActivityBar;
  WorkspacePreferenceCommandPalette: IWorkspacePreferenceCommandPalette;
  WorkspacePreferenceEditor: IWorkspacePreferenceEditor;
  WorkspacePreferenceExperimental: IWorkspacePreferenceExperimental;
  WorkspacePreferenceList: IWorkspacePreferenceList;
  WorkspacePreferencePanel: IWorkspacePreferencePanel;
  WorkspacePreferenceQuickOpen: IWorkspacePreferenceQuickOpen;
  WorkspacePreferenceSettings: IWorkspacePreferenceSettings;
  WorkspacePreferenceSideBar: IWorkspacePreferenceSideBar;
  WorkspacePreferenceStatusBar: IWorkspacePreferenceStatusBar;
  WorkspacePreferenceTips: IWorkspacePreferenceTips;
  WorkspacePreferenceView: IWorkspacePreferenceView;
  WorkspacePreferenceWorkbench: IWorkspacePreferenceWorkbench;
  WorkspaceRes: IWorkspaceRes;
  WorkspaceSettings: IWorkspaceSettings;
  WorkspaceToOpen: IWorkspaceToOpen;
  WorkspaceValue_Input: IWorkspaceValue_Input;
  WriteFileOptions_Input: IWriteFileOptions_Input;
  WriteTextFileOptions_Input: IWriteTextFileOptions_Input;
};

export type ICacheControlDirectiveArgs = {   maxAge?: Maybe<Scalars['Int']>;
  scope?: Maybe<ICacheControlScope>; };

export type ICacheControlDirectiveResolver<Result, Parent, ContextType = ApolloContext, Args = ICacheControlDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type IActionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Action'] = IResolversParentTypes['Action']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  tooltip?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  class?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  checked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  radio?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  run?: Resolver<Maybe<IResolversTypes['ActionRun']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IActionItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ActionItem'] = IResolversParentTypes['ActionItem']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IActionRunResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ActionRun'] = IResolversParentTypes['ActionRun']> = {
  type?: Resolver<Maybe<IResolversTypes['GraphqlCallType']>, ParentType, ContextType>;
  document?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  variables?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IActionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Actions'] = IResolversParentTypes['Actions']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  command?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  actionItem?: Resolver<Maybe<IResolversTypes['ActionItem']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAddFoldersRequestResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['AddFoldersRequest'] = IResolversParentTypes['AddFoldersRequest']> = {
  foldersToAdd?: Resolver<Maybe<Array<Maybe<IResolversTypes['URI']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAdminIdeSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['AdminIdeSettings'] = IResolversParentTypes['AdminIdeSettings']> = {
  dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAnchorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Anchor'] = IResolversParentTypes['Anchor']> = {
  x?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  y?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  height?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  width?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IAnyObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['AnyObject'], any> {
  name: 'AnyObject';
}

export type IArgsTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ArgsType'] = IResolversParentTypes['ArgsType']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  constraint?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAssetsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Assets'] = IResolversParentTypes['Assets']> = {
  Type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  Content?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAuthorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Author'] = IResolversParentTypes['Author']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IBaseExtensionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['BaseExtension'] = IResolversParentTypes['BaseExtension']> = {
  type?: Resolver<Maybe<IResolversTypes['ExtensionType']>, ParentType, ContextType>;
  identifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
  galleryIdentifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
  manifest?: Resolver<Maybe<IResolversTypes['ExtensionManifest']>, ParentType, ContextType>;
  location?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IBigIntScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['BigInt'], any> {
  name: 'BigInt';
}

export type IBranchStatusResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['BranchStatus'] = IResolversParentTypes['BranchStatus']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IBundlesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Bundles'] = IResolversParentTypes['Bundles']> = {
  server?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  browser?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICachedSearchStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CachedSearchStats'] = IResolversParentTypes['CachedSearchStats']> = {
  cacheWasResolved?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  cacheLookupTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  cacheFilterTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  cacheEntryCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IChangeRangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ChangeRange'] = IResolversParentTypes['ChangeRange']> = {
  startLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  startColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IChangesChunkResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ChangesChunk'] = IResolversParentTypes['ChangesChunk']> = {
  range?: Resolver<Maybe<IResolversTypes['ChangeRange']>, ParentType, ContextType>;
  rangeLength?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  text?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  rangeOffset?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  forceMoveMarkers?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICheckboxOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CheckboxOptions'] = IResolversParentTypes['CheckboxOptions']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  checked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICloseDirectionResolvers = EnumResolverSignature<{ LEFT?: any, RIGHT?: any }, IResolversTypes['CloseDirection']>;

export type ICloseEditorsFilterResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CloseEditorsFilter'] = IResolversParentTypes['CloseEditorsFilter']> = {
  except?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  direction?: Resolver<Maybe<IResolversTypes['CloseDirection']>, ParentType, ContextType>;
  savedOnly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICodeEditorViewStateResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CodeEditorViewState'] = IResolversParentTypes['CodeEditorViewState']> = {
  cursorState?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  viewState?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  contributionsState?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICommandHandlerDescriptionTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CommandHandlerDescriptionType'] = IResolversParentTypes['CommandHandlerDescriptionType']> = {
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  args?: Resolver<Maybe<Array<Maybe<IResolversTypes['ArgsType']>>>, ParentType, ContextType>;
  returns?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICommandTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CommandType'] = IResolversParentTypes['CommandType']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  handler?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['CommandHandlerDescriptionType']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICommandsTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CommandsType'] = IResolversParentTypes['CommandsType']> = {
  commands?: Resolver<Maybe<Array<Maybe<IResolversTypes['CommandType']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Configuration'] = IResolversParentTypes['Configuration']> = {
  defaultSetting?: Resolver<Maybe<Array<Maybe<IResolversTypes['SettingsGroup']>>>, ParentType, ContextType>;
  files?: Resolver<Maybe<IResolversTypes['Files']>, ParentType, ContextType>;
  git?: Resolver<Maybe<IResolversTypes['Git']>, ParentType, ContextType>;
  languages?: Resolver<Maybe<IResolversTypes['Languages']>, ParentType, ContextType>;
  output?: Resolver<Maybe<IResolversTypes['Output']>, ParentType, ContextType>;
  search?: Resolver<Maybe<IResolversTypes['Search']>, ParentType, ContextType>;
  terminal?: Resolver<Maybe<IResolversTypes['Terminal']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceWorkbench']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ConfigurationData'] = IResolversParentTypes['ConfigurationData']> = {
  defaults?: Resolver<Maybe<IResolversTypes['ConfigurationModel']>, ParentType, ContextType>;
  user?: Resolver<Maybe<IResolversTypes['ConfigurationModel']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['ConfigurationModel']>, ParentType, ContextType>;
  folders?: Resolver<Maybe<Array<Maybe<IResolversTypes['FolderConfigurationModel']>>>, ParentType, ContextType>;
  isComplete?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationExtensionInfoResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ConfigurationExtensionInfo'] = IResolversParentTypes['ConfigurationExtensionInfo']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationModelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ConfigurationModel'] = IResolversParentTypes['ConfigurationModel']> = {
  contents?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  keys?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  overrides?: Resolver<Maybe<Array<Maybe<IResolversTypes['Overrides']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationOverridesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ConfigurationOverrides'] = IResolversParentTypes['ConfigurationOverrides']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  overrideIdentifier?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IConfigurationScopeResolvers = EnumResolverSignature<{ APPLICATION?: any, MACHINE?: any, WINDOW?: any, RESOURCE?: any }, IResolversTypes['ConfigurationScope']>;

export type IConfigurationTargetResolvers = EnumResolverSignature<{ USER?: any, USER_LOCAL?: any, USER_REMOTE?: any, WORKSPACE?: any, WORKSPACE_FOLDER?: any, DEFAULT?: any, MEMORY?: any }, IResolversTypes['ConfigurationTarget']>;

export type IContentChangedEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ContentChangedEvent'] = IResolversParentTypes['ContentChangedEvent']> = {
  changes?: Resolver<Maybe<Array<Maybe<IResolversTypes['ChangesChunk']>>>, ParentType, ContextType>;
  eol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  versionId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  isUndoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isRedoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isFlush?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IContextResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Context'] = IResolversParentTypes['Context']> = {
  originalResourceScheme?: Resolver<Maybe<IResolversTypes['scmResourceGroups']>, ParentType, ContextType>;
  view?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  viewItem?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  gitOpenRepositoryCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  isInDiffEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isInDiffRightEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  resourceScheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resourceFilename?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resourceLangId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  resourceExtName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resourceSet?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isFileSystemResource?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inputFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  suggestWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  suggestWidgetMultipleSuggestions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  suggestionMakesTextEdit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  acceptSuggestionOnEnter?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasOtherSuggestions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  groupFocusedInOpenEditors?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  dirtyEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  resourceSelectedForCompare?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileCopied?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  breadcrumbsPossible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  breadcrumbsVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  breadcrumbsActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canNavigateBack?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canNavigateForward?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canNavigateToLastEditLocation?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  dirtyDiffVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  cancellableOperation?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  parameterHintsVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  parameterHintsMultipleSignatures?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  markdownPreviewFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isMac?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isLinux?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isWindows?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  remoteAuthority?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  remoteConnectionState?: Resolver<Maybe<IResolversTypes['ProvidedRemoteConnectionStates']>, ParentType, ContextType>;
  hasMacNativeTabs?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  supportsWorkspaces?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isDevelopment?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workbenchState?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  workspaceFolderCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  remoteFileDialogVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isFullscreen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  atEndOfWord?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  scmRepository?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  scmProvider?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  scmResourceGroup?: Resolver<Maybe<IResolversTypes['scmResourceGroups']>, ParentType, ContextType>;
  inDiffEditorKey?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isDominatedByLongLines?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isWordWrapMinified?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  commentThread?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  commentThreadisEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  commentIsEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  commentEditorFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  interfaceOverviewVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inReferenceSearchEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  referenceSearchVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listSupportsMultiSelect?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listHasSelectionOrFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listDoubleSelection?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listMultiSelection?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  listSupportsKeyboardNavigation?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  WorkbenchListAutomaticKeyboardNavigationKey?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  accessibilityHelpWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inQuickOpenKey?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  supportedCodeAction?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  hasSymbols?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasSnippetCompletions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  messageVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasCallHierarchyProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  callHierarchyVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchViewletVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchViewletFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inputBoxFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchInputBoxFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  replaceInputBoxFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  patternIncludesInputBoxFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  patternExcludesInputBoxFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  replaceActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasSearchResult?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  firstMatchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileMatchOrMatchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileMatchOrFolderMatchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileMatchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  folderMatchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  matchFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inRecentFilesPicker?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inWindowsPicker?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  findWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  findInputFocussed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  replaceInputFocussed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorTextFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  textInputFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasSelection?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasMultipleSelections?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorTabMoveFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isInEmbeddedEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canUndo?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canRedo?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorLangId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  editorHasCompletionItemProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasCodeActionsProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasDefinitionProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasDeclarationProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasImplementationProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasTypeDefinitionProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasHoverProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHadDocumentHighlightProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasDocumentSymbolProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasReferenceProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasRenameProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasSignatureHelpProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasDocumentFormattingProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasDocumentSelectionFormattingProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorHasMultipleDocumentSelectionFormattingProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  activeEditor?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  editorIsOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  groupActiveEditorDirty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  groupEditorsCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  textCompareEditorVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  textCompareEditorActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  activeEditorGroupEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  multipleEditorGroups?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inZenMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inCenteredLayout?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  splitEditorsVertically?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  sideBarVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  sideBarFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  activeViewlet?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  activePanel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  panelFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  panelPosition?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  debugType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  debugConfigurationType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  debugState?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  inDebugMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inDebugRepl?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  breakpointWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  watchExpressionsFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  variablesFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  expressionSelected?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  breakpointSelected?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  callStackItemType?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  loadedScriptsSupported?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  loadedScriptsItemType?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  focusedSessionIsAttach?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  stepBackSupported?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  restartFrameSupported?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inSettingsEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inSettingsJSONEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inSettingsSearch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  settingsTocRowFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inKeybindings?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inKeybindingsSearch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  keybindingFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerViewletVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerResourceIsFolder?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerResourceReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerResourceIsRoot?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerResourceCut?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerResourceMoveableToTrash?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  filesExplorerFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  openEditorsVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  openEditorsFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  explorerViewletFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalIsOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalTextSelected?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalFindWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalFindWidgetInputFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  terminalFindWidgetFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  webviewFindWidgetVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  taskRunning?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  referenceSearchTreeFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  interactivePlaygroundFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  outlineFiltered?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  outlineFocused?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  problemsViewFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  problemFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  problemsFilterFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  relatedInformationFocus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inOutput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  activeLogOutput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  multiCursorModifier?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  saveConflictResolutionContext?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  markersNavigationVisible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasWordHighlights?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  profileSessionState?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionHostProfileRecorded?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  historyNavigationEnabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  historyNavigationWidget?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  nonEmptyWorkspace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  defaultExtensionViews?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchMarketplaceExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchInstalledExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchOutdatedExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchEnabledExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchDisabledExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasInstalledExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  searchBuiltInExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  recommendedExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  defaultRecommendedExtensions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workspaceRecommendations?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workspaceFolderRecommendations?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  addToWorkspaceRecommendations?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  addToWorkspaceFolderRecommendations?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IContextMenuResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ContextMenu'] = IResolversParentTypes['ContextMenu']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isShow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  anchor?: Resolver<Maybe<IResolversTypes['Anchor']>, ParentType, ContextType>;
  menuItems?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IContributesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Contributes'] = IResolversParentTypes['Contributes']> = {
  menus?: Resolver<Maybe<IResolversTypes['Menus']>, ParentType, ContextType>;
  actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['Actions']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICrashReporterStartOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CrashReporterStartOptions'] = IResolversParentTypes['CrashReporterStartOptions']> = {
  companyName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  submitURL?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  productName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  uploadToServer?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  ignoreSystemCrashHandler?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  extra?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  crashesDirectory?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ICursorStateResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['CursorState'] = IResolversParentTypes['CursorState']> = {
  inSelectionMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  selectionStart?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  position?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDataUriEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DataUriEditorInput'] = IResolversParentTypes['DataUriEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  mime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IDateScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Date'], any> {
  name: 'Date';
}

export interface IDateTimeScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['DateTime'], any> {
  name: 'DateTime';
}

export type IDebuggerResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Debugger'] = IResolversParentTypes['Debugger']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  runtime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDefaultPreferencesResponseResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DefaultPreferencesResponse'] = IResolversParentTypes['DefaultPreferencesResponse']> = {
  preferences?: Resolver<Maybe<Array<Maybe<IResolversTypes['PreferencesType']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDefaultSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DefaultSettings'] = IResolversParentTypes['DefaultSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDetailResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Detail'] = IResolversParentTypes['Detail']> = {
  inputName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  inputType?: Resolver<Maybe<IResolversTypes['InputTypeDetail']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  placeholder?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  defaultValue?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  required?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDevToolsOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DevToolsOptions'] = IResolversParentTypes['DevToolsOptions']> = {
  mode?: Resolver<Maybe<IResolversTypes['DevToolsOptionsMode']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDialogResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Dialog'] = IResolversParentTypes['Dialog']> = {
  dialogType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  detail?: Resolver<Maybe<Array<Maybe<IResolversTypes['Detail']>>>, ParentType, ContextType>;
  primaryButton?: Resolver<Maybe<IResolversTypes['PrimaryButtonAction']>, ParentType, ContextType>;
  secondaryButton?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  checkbox?: Resolver<Maybe<IResolversTypes['CheckboxOptions']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDialogResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DialogResult'] = IResolversParentTypes['DialogResult']> = {
  confirmed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  checkboxChecked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDiffEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DiffEditorInput'] = IResolversParentTypes['DiffEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  originalInput?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  modifiedInput?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDocSitePageResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DocSitePage'] = IResolversParentTypes['DocSitePage']> = {
  title?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  contentHTML?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  indexHTML?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  filePath?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDockLayoutResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DockLayout'] = IResolversParentTypes['DockLayout']> = {
  id?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  activeId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['GroupOrientation']>, ParentType, ContextType>;
  children?: Resolver<Maybe<Array<Maybe<IResolversTypes['DockLayout']>>>, ParentType, ContextType>;
  tabs?: Resolver<Maybe<Array<Maybe<IResolversTypes['EditorInput']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IDocumentFilterResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['DocumentFilter'] = IResolversParentTypes['DocumentFilter']> = {
  language?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  schema?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  pattern?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditKeybindingItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditKeybindingItem'] = IResolversParentTypes['EditKeybindingItem']> = {
  command?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isDefault?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorChildrenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorChildren'] = IResolversParentTypes['EditorChildren']> = {
  __resolveType: TypeResolveFn<'EditorPart' | 'EditorGroup', ParentType, ContextType>;
};

export type IEditorGroupResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorGroup'] = IResolversParentTypes['EditorGroup']> = {
  id?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  activeId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  tabs?: Resolver<Maybe<Array<Maybe<IResolversTypes['EditorInput']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorGroupLayoutResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorGroupLayout'] = IResolversParentTypes['EditorGroupLayout']> = {
  orientation?: Resolver<Maybe<IResolversTypes['GroupOrientation']>, ParentType, ContextType>;
  groups?: Resolver<Maybe<Array<Maybe<IResolversTypes['GroupLayoutArgument']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorIdentifierResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorIdentifier'] = IResolversParentTypes['EditorIdentifier']> = {
  groupId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  editor?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorInput'] = IResolversParentTypes['EditorInput']> = {
  __resolveType: TypeResolveFn<'DataUriEditorInput' | 'DiffEditorInput' | 'FileEditorInput' | 'KeybindingEditorInput' | 'PreferencesEditorInput' | 'ResourceEditorInput' | 'SideBySideEditorInput' | 'UntitledEditorInput', ParentType, ContextType>;
};

export type IEditorOpenPositioningResolvers = EnumResolverSignature<{ LEFT?: any, RIGHT?: any, FIRST?: any, LAST?: any }, IResolversTypes['EditorOpenPositioning']>;

export type IEditorPartResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorPart'] = IResolversParentTypes['EditorPart']> = {
  id?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['GroupOrientation']>, ParentType, ContextType>;
  height?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  children?: Resolver<Maybe<Array<Maybe<IResolversTypes['EditorChildren']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorPartOptions_InputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorPartOptions_Input'] = IResolversParentTypes['EditorPartOptions_Input']> = {
  showTabs?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  highlightModifiedTabs?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  tabCloseButton?: Resolver<Maybe<IResolversTypes['TabCloseButtonType']>, ParentType, ContextType>;
  tabSizing?: Resolver<Maybe<IResolversTypes['TabSizingType']>, ParentType, ContextType>;
  focusRecentEditorAfterClose?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showIcons?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enablePreview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enablePreviewFromQuickOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  closeOnFileDelete?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  openPositioning?: Resolver<Maybe<IResolversTypes['OpenPositioningType']>, ParentType, ContextType>;
  openSideBySideDirection?: Resolver<Maybe<IResolversTypes['OpenSideBySideDirection']>, ParentType, ContextType>;
  closeEmptyGroup?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  revealIfOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  swipeToNavigate?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  labelFormat?: Resolver<Maybe<IResolversTypes['LableFormatType']>, ParentType, ContextType>;
  restoreViewState?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  iconTheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EditorSettings'] = IResolversParentTypes['EditorSettings']> = {
  editorOpenPositioning?: Resolver<Maybe<IResolversTypes['EditorOpenPositioning']>, ParentType, ContextType>;
  focusRecentEditorAfterClose?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEditorsOrderResolvers = EnumResolverSignature<{ MOST_RECENTLY_ACTIVE?: any, SEQUENTIAL?: any }, IResolversTypes['EditorsOrder']>;

export type IEmptyResponseResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EmptyResponse'] = IResolversParentTypes['EmptyResponse']> = {
  alwaysNil?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEncodingStatusResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EncodingStatus'] = IResolversParentTypes['EncodingStatus']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEndOfLineSequenceResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EndOfLineSequence'] = IResolversParentTypes['EndOfLineSequence']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEnginesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Engines'] = IResolversParentTypes['Engines']> = {
  node?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  vscode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEnterWorkspaceResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['EnterWorkspaceResult'] = IResolversParentTypes['EnterWorkspaceResult']> = {
  workspace?: Resolver<IResolversTypes['WorkspaceIdentifier'], ParentType, ContextType>;
  backupPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IEnvironmentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Environment'] = IResolversParentTypes['Environment']> = {
  args?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  execPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  cliPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appRoot?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  userHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  userDataPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appNameLong?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appQuality?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appSettingsHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appSettingsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appKeybindingsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  settingsSearchBuildId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  settingsSearchUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  globalStorageHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  workspaceStorageHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  backupHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  backupWorkspacesPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  untitledWorkspacesHome?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  workspacesHome?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  workspacesProjectPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  workspaceSettingsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isExtensionDevelopment?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  disableExtensions?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  builtinExtensionsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionDevelopmentLocationURI?: Resolver<Maybe<Array<Maybe<IResolversTypes['URI']>>>, ParentType, ContextType>;
  extensionTestsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  debugExtensionHost?: Resolver<Maybe<IResolversTypes['ExtensionHostDebugParams']>, ParentType, ContextType>;
  debugSearch?: Resolver<Maybe<IResolversTypes['IDebugParams']>, ParentType, ContextType>;
  logExtensionHostCommunication?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isBuilt?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  wait?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  performance?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  log?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  logsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  verbose?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  logLevel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  skipGettingStarted?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  skipReleaseNotes?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  skipAddToRecentlyOpened?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  nodeCachedDataDir?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  installSourcePath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  disableUpdates?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  disableCrashReporter?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  driverHandle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  driverVerbose?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  keyboardLayoutResource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  keybindingsResource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  userRoamingDataHome?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  settingsResource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionColorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionColor'] = IResolversParentTypes['ExtensionColor']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  defaults?: Resolver<Maybe<IResolversTypes['ExtensionColorTypes']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionColorTypesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionColorTypes'] = IResolversParentTypes['ExtensionColorTypes']> = {
  light?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  dark?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  highContrast?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionConfigurationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionConfiguration'] = IResolversParentTypes['ExtensionConfiguration']> = {
  properties?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionConfigurationPropertyResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionConfigurationProperty'] = IResolversParentTypes['ExtensionConfigurationProperty']> = {
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  type?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  defaults?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionContributionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionContributions'] = IResolversParentTypes['ExtensionContributions']> = {
  actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['Actions']>>>, ParentType, ContextType>;
  commands?: Resolver<Maybe<Array<Maybe<IResolversTypes['Actions']>>>, ParentType, ContextType>;
  configuration?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionConfiguration']>>>, ParentType, ContextType>;
  debuggers?: Resolver<Maybe<Array<Maybe<IResolversTypes['Debugger']>>>, ParentType, ContextType>;
  grammars?: Resolver<Maybe<Array<Maybe<IResolversTypes['Grammar']>>>, ParentType, ContextType>;
  jsonValidation?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionJSONValidation']>>>, ParentType, ContextType>;
  keybindings?: Resolver<Maybe<Array<Maybe<IResolversTypes['KeyBinding']>>>, ParentType, ContextType>;
  languages?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionLanguage']>>>, ParentType, ContextType>;
  menus?: Resolver<Maybe<IResolversTypes['Menus']>, ParentType, ContextType>;
  snippets?: Resolver<Maybe<Array<Maybe<IResolversTypes['Snippet']>>>, ParentType, ContextType>;
  themes?: Resolver<Maybe<Array<Maybe<IResolversTypes['ThemeLabel']>>>, ParentType, ContextType>;
  iconThemes?: Resolver<Maybe<Array<Maybe<IResolversTypes['ThemeLabel']>>>, ParentType, ContextType>;
  viewsContainers?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  views?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  colors?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionColor']>>>, ParentType, ContextType>;
  localizations?: Resolver<Maybe<Array<Maybe<IResolversTypes['Localization']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionHostDebugParamsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionHostDebugParams'] = IResolversParentTypes['ExtensionHostDebugParams']> = {
  port?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  break?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  debugId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionIdentifierResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionIdentifier'] = IResolversParentTypes['ExtensionIdentifier']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  uuid?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionInstanceResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionInstance'] = IResolversParentTypes['ExtensionInstance']> = {
  pid?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  env?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionID?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  monit?: Resolver<Maybe<IResolversTypes['ProcessMonitoring']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionJsonValidationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionJSONValidation'] = IResolversParentTypes['ExtensionJSONValidation']> = {
  fileMatch?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionLanguageResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionLanguage'] = IResolversParentTypes['ExtensionLanguage']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  extensions?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  aliases?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionManifestResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionManifest'] = IResolversParentTypes['ExtensionManifest']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  version?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  main?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  badges?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  keywords?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  license?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  homepage?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  publisher?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  categories?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionID?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  displayName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  dependencies?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  devDependencies?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  extensionPack?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  extensionKind?: Resolver<Maybe<IResolversTypes['ExtensionKind']>, ParentType, ContextType>;
  extensionDependencies?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  bundle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  raw?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  assets?: Resolver<Maybe<Array<Maybe<IResolversTypes['Assets']>>>, ParentType, ContextType>;
  scripts?: Resolver<Maybe<IResolversTypes['Scripts']>, ParentType, ContextType>;
  bundles?: Resolver<Maybe<IResolversTypes['Bundles']>, ParentType, ContextType>;
  bundleURL?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extension?: Resolver<Maybe<IResolversTypes['ExtensionPackageType']>, ParentType, ContextType>;
  engines?: Resolver<Maybe<IResolversTypes['Engines']>, ParentType, ContextType>;
  makrdown?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  qna?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  author?: Resolver<Maybe<IResolversTypes['Author']>, ParentType, ContextType>;
  galleryBanner?: Resolver<Maybe<IResolversTypes['GalleryBanner']>, ParentType, ContextType>;
  activationEvents?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  contributes?: Resolver<Maybe<IResolversTypes['ExtensionContributions']>, ParentType, ContextType>;
  icon?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  bugs?: Resolver<Maybe<IResolversTypes['ExtensionManifestBugs']>, ParentType, ContextType>;
  repository?: Resolver<Maybe<IResolversTypes['ExtensionManifestRepository']>, ParentType, ContextType>;
  enableProposedApi?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  api?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionManifestBugsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionManifestBugs'] = IResolversParentTypes['ExtensionManifestBugs']> = {
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  email?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionManifestRepositoryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionManifestRepository'] = IResolversParentTypes['ExtensionManifestRepository']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionPackageTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionPackageType'] = IResolversParentTypes['ExtensionPackageType']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionRegistryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionRegistry'] = IResolversParentTypes['ExtensionRegistry']> = {
  extension?: Resolver<Maybe<IResolversTypes['RegistryExtension']>, ParentType, ContextType, RequireFields<IExtensionRegistryExtensionArgs, 'extensionID'>>;
  extensions?: Resolver<IResolversTypes['RegistryExtensionConnection'], ParentType, ContextType, RequireFields<IExtensionRegistryExtensionsArgs, 'local' | 'remote' | 'includeWIP'>>;
  releases?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionRelease']>>>, ParentType, ContextType, RequireFields<IExtensionRegistryReleasesArgs, 'extensionID'>>;
  publishers?: Resolver<IResolversTypes['RegistryPublisherConnection'], ParentType, ContextType, RequireFields<IExtensionRegistryPublishersArgs, never>>;
  viewerPublishers?: Resolver<Array<IResolversTypes['RegistryPublisher']>, ParentType, ContextType>;
  localExtensionIDPrefix?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionRegistryCreateExtensionResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionRegistryCreateExtensionResult'] = IResolversParentTypes['ExtensionRegistryCreateExtensionResult']> = {
  extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionRegistryPublishExtensionResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionRegistryPublishExtensionResult'] = IResolversParentTypes['ExtensionRegistryPublishExtensionResult']> = {
  extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionRegistryUpdateExtensionResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionRegistryUpdateExtensionResult'] = IResolversParentTypes['ExtensionRegistryUpdateExtensionResult']> = {
  extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IExtensionReleaseResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ExtensionRelease'] = IResolversParentTypes['ExtensionRelease']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  bundle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  bundleURL?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  version?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  manifest?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  sourceMap?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionID?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  creatorUserId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  releaseVersion?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  activationEvents?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFieldErrorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FieldError'] = IResolversParentTypes['FieldError']> = {
  field?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  message?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileChangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileChange'] = IResolversParentTypes['FileChange']> = {
  type?: Resolver<Maybe<IResolversTypes['FileChangeType']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileContent'] = IResolversParentTypes['FileContent']> = {
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['VSBuffer']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileDeleteOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileDeleteOptions'] = IResolversParentTypes['FileDeleteOptions']> = {
  recursive?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  useTrash?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileEditorInput'] = IResolversParentTypes['FileEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preferredEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  forceOpenAsBinary?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileFilterResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileFilter'] = IResolversParentTypes['FileFilter']> = {
  extensions?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileIndexProviderStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileIndexProviderStats'] = IResolversParentTypes['FileIndexProviderStats']> = {
  providerTime?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  providerResultCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  fileWalkTime?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  directoriesWalked?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  filesWalked?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileMatchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileMatch'] = IResolversParentTypes['FileMatch']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  results?: Resolver<Maybe<Array<Maybe<IResolversTypes['TextSearchResult']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileOpenOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileOpenOptions'] = IResolversParentTypes['FileOpenOptions']> = {
  create?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileOperationOutputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileOperationOutput'] = IResolversParentTypes['FileOperationOutput']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  target?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  operation?: Resolver<Maybe<IResolversTypes['FileOperation']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileOverwriteOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileOverwriteOptions'] = IResolversParentTypes['FileOverwriteOptions']> = {
  overwrite?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileResult'] = IResolversParentTypes['FileResult']> = {
  source?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  target?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  success?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileSearchProviderStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileSearchProviderStats'] = IResolversParentTypes['FileSearchProviderStats']> = {
  providerTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  postProcessTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileSearchStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileSearchStats'] = IResolversParentTypes['FileSearchStats']> = {
  fromCache?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  detailStats?: Resolver<Maybe<IResolversTypes['FileSearchStatsdetailStats']>, ParentType, ContextType>;
  resultCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  type?: Resolver<Maybe<IResolversTypes['FileSearchStatsType']>, ParentType, ContextType>;
  sortingTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileSearchStatsdetailStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileSearchStatsdetailStats'] = IResolversParentTypes['FileSearchStatsdetailStats']> = {
  __resolveType: TypeResolveFn<'SearchEngineStats' | 'CachedSearchStats' | 'FileSearchProviderStats' | 'FileIndexProviderStats', ParentType, ContextType>;
};

export type IFileStatResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileStat'] = IResolversParentTypes['FileStat']> = {
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  mtime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isDirectory?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isSymbolicLink?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  children?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileStat']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileStatWithMetadataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileStatWithMetadata'] = IResolversParentTypes['FileStatWithMetadata']> = {
  active?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  changes?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  children?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileStatWithMetadata']>>>, ParentType, ContextType>;
  childrenGen?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileStatWithMetadata']>>>, ParentType, ContextType>;
  dirty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  eol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  expanded?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasChildren?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inConflictMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inErrorMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inOrphanMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inPendingSave?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isDirectory?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isFlush?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isRedoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isSymbolicLink?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isUndoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  resourcePath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  state?: Resolver<Maybe<IResolversTypes['FileModelState']>, ParentType, ContextType>;
  subtitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  versionId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileStreamContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileStreamContent'] = IResolversParentTypes['FileStreamContent']> = {
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['VSBufferReadableStream']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileToOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileToOpen'] = IResolversParentTypes['FileToOpen']> = {
  fileUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFileWriteOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FileWriteOptions'] = IResolversParentTypes['FileWriteOptions']> = {
  overwrite?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  create?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFilesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Files'] = IResolversParentTypes['Files']> = {
  eol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  hotExit?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  autoSave?: Resolver<Maybe<IResolversTypes['AutoSaveConfigurationType']>, ParentType, ContextType>;
  autoSaveDelay?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  defaultLanguage?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  autoGuessEncoding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  insertFinalNewline?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  trimTrailingWhitespace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  useExperimentalFileWatcher?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  watcherExclude?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  exclude?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFiles_StatResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Files_Stat'] = IResolversParentTypes['Files_Stat']> = {
  type?: Resolver<Maybe<IResolversTypes['FileType']>, ParentType, ContextType>;
  mtime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  ctime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFolderConfigurationModelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FolderConfigurationModel'] = IResolversParentTypes['FolderConfigurationModel']> = {
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  contents?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  keys?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  overrides?: Resolver<Maybe<IResolversTypes['ConfigurationOverrides']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFolderQueryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FolderQuery'] = IResolversParentTypes['FolderQuery']> = {
  folder?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  excludePattern?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  includePattern?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  fileEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  disregardIgnoreFiles?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFolderSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FolderSettings'] = IResolversParentTypes['FolderSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IFolderToOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['FolderToOpen'] = IResolversParentTypes['FolderToOpen']> = {
  folderUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryBannerResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryBanner'] = IResolversParentTypes['GalleryBanner']> = {
  color?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  theme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryExtensionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryExtension'] = IResolversParentTypes['GalleryExtension']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  identifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
  version?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  date?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  icon?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  displayName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  publisherId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  publisher?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  publisherDisplayName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  installCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  rating?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  ratingCount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  assets?: Resolver<Maybe<IResolversTypes['GalleryExtensionAssets']>, ParentType, ContextType>;
  properties?: Resolver<Maybe<IResolversTypes['GalleryExtensionProperties']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  resources?: Resolver<Maybe<IResolversTypes['GalleryExtensionResources']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryExtensionAssetResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryExtensionAsset'] = IResolversParentTypes['GalleryExtensionAsset']> = {
  uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fallbackUri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryExtensionAssetsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryExtensionAssets'] = IResolversParentTypes['GalleryExtensionAssets']> = {
  manifest?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  readme?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  changelog?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  download?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  icon?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  license?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  repository?: Resolver<Maybe<IResolversTypes['GalleryExtensionAsset']>, ParentType, ContextType>;
  coreTranslations?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryExtensionPropertiesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryExtensionProperties'] = IResolversParentTypes['GalleryExtensionProperties']> = {
  engine?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  dependencies?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  extensionPack?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  localizedLanguages?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryExtensionResourcesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryExtensionResources'] = IResolversParentTypes['GalleryExtensionResources']> = {
  manifest?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  readme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  changelog?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  download?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  icon?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  license?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  repository?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGalleryPagerResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GalleryPager'] = IResolversParentTypes['GalleryPager']> = {
  page?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  pageSize?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  firstPage?: Resolver<Maybe<Array<Maybe<IResolversTypes['GalleryExtension']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGeoLocationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GeoLocation'] = IResolversParentTypes['GeoLocation']> = {
  coordinates?: Resolver<Maybe<Array<Maybe<IResolversTypes['Float']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGitResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Git'] = IResolversParentTypes['Git']> = {
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  autofetch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  countBadge?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  autorefresh?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  confirmSync?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  checkoutType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  inputValidation?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  detectSubmodules?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enableSmartCommit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  ignoreLimitWarning?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  ignoreLegacyWarning?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enableCommitSigning?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  defaultCloneDirectory?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  autoRepositoryDetection?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  ignoreMissingGitWarning?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showInlineOpenFileAction?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  promptToSaveFilesBeforeCommit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  decorations?: Resolver<Maybe<IResolversTypes['GitDecorations']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGitDecorationsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GitDecorations'] = IResolversParentTypes['GitDecorations']> = {
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGlobalSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GlobalSettings'] = IResolversParentTypes['GlobalSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGoToLineQuickAccessResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GoToLineQuickAccess'] = IResolversParentTypes['GoToLineQuickAccess']> = {
  range?: Resolver<Maybe<IResolversTypes['LineRange']>, ParentType, ContextType>;
  highlight?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  focus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGrammarResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Grammar'] = IResolversParentTypes['Grammar']> = {
  language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGroupDirectionResolvers = EnumResolverSignature<{ UP?: any, DOWN?: any, LEFT?: any, RIGHT?: any }, IResolversTypes['GroupDirection']>;

export type IGroupLayoutArgumentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['GroupLayoutArgument'] = IResolversParentTypes['GroupLayoutArgument']> = {
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  groups?: Resolver<Maybe<Array<Maybe<IResolversTypes['GroupLayoutArgument']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IGroupLocationResolvers = EnumResolverSignature<{ FIRST?: any, LAST?: any, NEXT?: any, PREVIOUS?: any }, IResolversTypes['GroupLocation']>;

export type IGroupOrientationResolvers = EnumResolverSignature<{ HORIZONTAL?: any, VERTICAL?: any }, IResolversTypes['GroupOrientation']>;

export type IGroupsArrangementResolvers = EnumResolverSignature<{ MINIMIZE_OTHERS?: any, EVEN?: any }, IResolversTypes['GroupsArrangement']>;

export type IGroupsOrderResolvers = EnumResolverSignature<{ CREATION_TIME?: any, MOST_RECENTLY_ACTIVE?: any, GRID_APPEARANCE?: any }, IResolversTypes['GroupsOrder']>;

export type IHoverResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Hover'] = IResolversParentTypes['Hover']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  contents?: Resolver<Maybe<IResolversTypes['MarkupContent']>, ParentType, ContextType>;
  range?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
};

export type IIBaseStatResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IBaseStat'] = IResolversParentTypes['IBaseStat']> = {
  __resolveType: TypeResolveFn<'FileContent' | 'FileStat' | 'FileStatWithMetadata' | 'FileStreamContent' | 'TextFileContent' | 'TextFilePublishContent' | 'TextFileStreamContent', ParentType, ContextType>;
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  mtime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIBaseStatWithMetadataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IBaseStatWithMetadata'] = IResolversParentTypes['IBaseStatWithMetadata']> = {
  __resolveType: TypeResolveFn<'FileContent' | 'FileStatWithMetadata' | 'FileStreamContent' | 'TextFileContent' | 'TextFileStreamContent', ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
};

export type IIBaseTextFileContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IBaseTextFileContent'] = IResolversParentTypes['IBaseTextFileContent']> = {
  __resolveType: TypeResolveFn<'TextFileContent' | 'TextFilePublishContent' | 'TextFileStreamContent', ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IIBehaviorSubjectResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IBehaviorSubject'] = IResolversParentTypes['IBehaviorSubject']> = {
  closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasError?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isStopped?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  observers?: Resolver<Maybe<Array<Maybe<IResolversTypes['JSON']>>>, ParentType, ContextType>;
  thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  value?: Resolver<Maybe<Array<Maybe<IResolversTypes['IBehaviorSubjectValue']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIBehaviorSubjectValueResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IBehaviorSubjectValue'] = IResolversParentTypes['IBehaviorSubjectValue']> = {
  provider?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  registrationOptions?: Resolver<Maybe<IResolversTypes['IDocumentSelector']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IICommonQueryPropsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ICommonQueryProps'] = IResolversParentTypes['ICommonQueryProps']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  _reason?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  folderQueries?: Resolver<Maybe<Array<Maybe<IResolversTypes['FolderQuery']>>>, ParentType, ContextType>;
  includePattern?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  excludePattern?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  extraFileResources?: Resolver<Maybe<Array<Maybe<IResolversTypes['URI']>>>, ParentType, ContextType>;
  useRipgrep?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  maxResults?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  usingSearchPaths?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIConfigurationChangeEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IConfigurationChangeEvent'] = IResolversParentTypes['IConfigurationChangeEvent']> = {
  source?: Resolver<Maybe<IResolversTypes['ConfigurationTarget']>, ParentType, ContextType>;
  affectedKeys?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  sourceConfig?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  changedConfiguration?: Resolver<Maybe<IResolversTypes['ConfigurationModel']>, ParentType, ContextType>;
  changedConfigurationByResource?: Resolver<Maybe<IResolversTypes['ResourceMapConfigurationModel']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIConfigurationServiceResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IConfigurationService'] = IResolversParentTypes['IConfigurationService']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  updateValue?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IIConfigurationServiceUpdateValueArgs, 'key' | 'value' | 'overrides'>>;
};

export type IIContentChangedEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IContentChangedEvent'] = IResolversParentTypes['IContentChangedEvent']> = {
  __resolveType: TypeResolveFn<'FileStatWithMetadata', ParentType, ContextType>;
  changes?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  eol?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  versionId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  isUndoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isRedoing?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isFlush?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIDebugParamsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IDebugParams'] = IResolversParentTypes['IDebugParams']> = {
  __resolveType: TypeResolveFn<'ExtensionHostDebugParams', ParentType, ContextType>;
  port?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  break?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIDestinationAnonymousSubjectResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IDestinationAnonymousSubject'] = IResolversParentTypes['IDestinationAnonymousSubject']> = {
  closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  destination?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  hasError?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isStopped?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  observers?: Resolver<Maybe<Array<Maybe<IResolversTypes['JSON']>>>, ParentType, ContextType>;
  operator?: Resolver<Maybe<IResolversTypes['ISwitchMapOperator']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['IBehaviorSubject']>, ParentType, ContextType>;
  thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIDocumentSelectorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IDocumentSelector'] = IResolversParentTypes['IDocumentSelector']> = {
  documentSelector?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIEditorGroupResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IEditorGroup'] = IResolversParentTypes['IEditorGroup']> = {
  __resolveType: TypeResolveFn<'EditorGroup', ParentType, ContextType>;
  id?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IIEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IEditorInput'] = IResolversParentTypes['IEditorInput']> = {
  __resolveType: TypeResolveFn<'DataUriEditorInput' | 'DiffEditorInput' | 'FileEditorInput' | 'KeybindingEditorInput' | 'PreferencesEditorInput' | 'ResourceEditorInput' | 'SideBySideEditorInput' | 'UntitledEditorInput', ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIEditorInputWithGroupFieldsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IEditorInputWithGroupFields'] = IResolversParentTypes['IEditorInputWithGroupFields']> = {
  __resolveType: TypeResolveFn<'DataUriEditorInput' | 'DiffEditorInput' | 'FileEditorInput' | 'KeybindingEditorInput' | 'PreferencesEditorInput' | 'ResourceEditorInput' | 'SideBySideEditorInput' | 'UntitledEditorInput', ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIEncodingSupportResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IEncodingSupport'] = IResolversParentTypes['IEncodingSupport']> = {
  __resolveType: TypeResolveFn<'FileEditorInput', ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IIFileClientMetadataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IFileClientMetadata'] = IResolversParentTypes['IFileClientMetadata']> = {
  __resolveType: TypeResolveFn<'FileStatWithMetadata' | 'TextFileContent', ParentType, ContextType>;
  dirty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inConflictMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inOrphanMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inErrorMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inPendingSave?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  state?: Resolver<Maybe<IResolversTypes['FileModelState']>, ParentType, ContextType>;
};

export type IIFileEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IFileEditorInput'] = IResolversParentTypes['IFileEditorInput']> = {
  __resolveType: TypeResolveFn<'FileEditorInput', ParentType, ContextType>;
  preferredEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  forceOpenAsBinary?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIFileMatchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IFileMatch'] = IResolversParentTypes['IFileMatch']> = {
  __resolveType: TypeResolveFn<'FileMatch' | 'SearchProgressItem', ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  results?: Resolver<Maybe<Array<Maybe<IResolversTypes['TextSearchResult']>>>, ParentType, ContextType>;
};

export type IIFileSystemProviderActivationEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IFileSystemProviderActivationEvent'] = IResolversParentTypes['IFileSystemProviderActivationEvent']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  scheme?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};

export type IIFileSystemProviderRegistrationEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IFileSystemProviderRegistrationEvent'] = IResolversParentTypes['IFileSystemProviderRegistrationEvent']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  added?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  scheme?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};

export type IIModeSupportResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IModeSupport'] = IResolversParentTypes['IModeSupport']> = {
  __resolveType: TypeResolveFn<'FileEditorInput', ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IIModelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IModel'] = IResolversParentTypes['IModel']> = {
  roots?: Resolver<Maybe<IResolversTypes['IWorkspaceRoot']>, ParentType, ContextType>;
  visibleViewComponents?: Resolver<Maybe<Array<Maybe<IResolversTypes['IViewComponentData']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIObservableResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IObservableResult'] = IResolversParentTypes['IObservableResult']> = {
  closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  destination?: Resolver<Maybe<IResolversTypes['IDestinationAnonymousSubject']>, ParentType, ContextType>;
  hasError?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isStopped?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  observers?: Resolver<Maybe<Array<Maybe<IResolversTypes['JSON']>>>, ParentType, ContextType>;
  operator?: Resolver<Maybe<IResolversTypes['ISwitchMapOperator']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['ISourceAnonymousSubject']>, ParentType, ContextType>;
  thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIPathDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IPathData'] = IResolversParentTypes['IPathData']> = {
  __resolveType: TypeResolveFn<'Path', ParentType, ContextType>;
  fileUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  lineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  columnNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  exists?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIPathsToWaitForDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IPathsToWaitForData'] = IResolversParentTypes['IPathsToWaitForData']> = {
  __resolveType: TypeResolveFn<'PathsToWaitFor', ParentType, ContextType>;
  paths?: Resolver<Maybe<Array<Maybe<IResolversTypes['IPathData']>>>, ParentType, ContextType>;
  waitMarkerFileUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
};

export type IIResourceUtilizationSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IResourceUtilizationSettings'] = IResolversParentTypes['IResourceUtilizationSettings']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  subTopic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  adminApiNamespace?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IISearchCompleteStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISearchCompleteStats'] = IResolversParentTypes['ISearchCompleteStats']> = {
  __resolveType: TypeResolveFn<'SearchComplete', ParentType, ContextType>;
  limitHit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  stats?: Resolver<Maybe<IResolversTypes['SearchCompleteStatsStats']>, ParentType, ContextType>;
};

export type IISearchProgressResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISearchProgress'] = IResolversParentTypes['ISearchProgress']> = {
  __resolveType: TypeResolveFn<'SearchProgressItem', ParentType, ContextType>;
  total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  worked?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IISettingsSubjectResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISettingsSubject'] = IResolversParentTypes['ISettingsSubject']> = {
  __resolveType: TypeResolveFn<'DefaultSettings' | 'FolderSettings' | 'GlobalSettings' | 'LocalUserSettings' | 'MemorySettings' | 'RemoteUserSettings' | 'UserSettings' | 'WorkspaceSettings', ParentType, ContextType>;
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
};

export type IISideBySideEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISideBySideEditorInput'] = IResolversParentTypes['ISideBySideEditorInput']> = {
  __resolveType: TypeResolveFn<'PreferencesEditorInput' | 'SideBySideEditorInput', ParentType, ContextType>;
  master?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  details?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
};

export type IISourceAnonymousSubjectResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISourceAnonymousSubject'] = IResolversParentTypes['ISourceAnonymousSubject']> = {
  closed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  destination?: Resolver<Maybe<IResolversTypes['IDestinationAnonymousSubject']>, ParentType, ContextType>;
  hasError?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isStopped?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  observers?: Resolver<Maybe<Array<Maybe<IResolversTypes['JSON']>>>, ParentType, ContextType>;
  operator?: Resolver<Maybe<IResolversTypes['ISwitchMapOperator']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['IBehaviorSubject']>, ParentType, ContextType>;
  thrownError?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  _isScalar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIStaticWorkspaceDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IStaticWorkspaceData'] = IResolversParentTypes['IStaticWorkspaceData']> = {
  __resolveType: TypeResolveFn<'WorkspaceData', ParentType, ContextType>;
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  configuration?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  isUntitled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIStatusbarItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IStatusbarItem'] = IResolversParentTypes['IStatusbarItem']> = {
  __resolveType: TypeResolveFn<'BranchStatus' | 'EncodingStatus' | 'EndOfLineSequence' | 'Indentation' | 'LanguageMode' | 'SelectionStatus' | 'SyncStatus' | 'Terminal', ParentType, ContextType>;
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
};

export type IISwitchMapOperatorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ISwitchMapOperator'] = IResolversParentTypes['ISwitchMapOperator']> = {
  project?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IITextDocumentIdentifierResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ITextDocumentIdentifier'] = IResolversParentTypes['ITextDocumentIdentifier']> = {
  __resolveType: TypeResolveFn<'TextDocumentIdentifier' | 'TextDocumentItem', ParentType, ContextType>;
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IITreeItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ITreeItem'] = IResolversParentTypes['ITreeItem']> = {
  __resolveType: TypeResolveFn<'FileStatWithMetadata', ParentType, ContextType>;
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  subtitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isDirectory?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  active?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  expanded?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasChildren?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIUntitledFileValueResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IUntitledFileValue'] = IResolversParentTypes['IUntitledFileValue']> = {
  __resolveType: TypeResolveFn<'FileStatWithMetadata', ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IIUserPreferencesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IUserPreferences'] = IResolversParentTypes['IUserPreferences']> = {
  content?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  user?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIUserSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IUserSettings'] = IResolversParentTypes['IUserSettings']> = {
  data?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIViewComponentDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IViewComponentData'] = IResolversParentTypes['IViewComponentData']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  item?: Resolver<Maybe<IResolversTypes['TextDocumentItem']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIViewDescriptorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IViewDescriptor'] = IResolversParentTypes['IViewDescriptor']> = {
  __resolveType: TypeResolveFn<'TreeViewDescriptor' | 'ViewDescriptor', ParentType, ContextType>;
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  order?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  weight?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  collapsed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canToggleVisibility?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hideByDefault?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type IIWorkspaceRootResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['IWorkspaceRoot'] = IResolversParentTypes['IWorkspaceRoot']> = {
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IImportResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ImportResult'] = IResolversParentTypes['ImportResult']> = {
  stat?: Resolver<Maybe<IResolversTypes['FileStat']>, ParentType, ContextType>;
  isNew?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIndentationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Indentation'] = IResolversParentTypes['Indentation']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IInputTypeDetailResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['InputTypeDetail'] = IResolversParentTypes['InputTypeDetail']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  options?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IInstalledExtensionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['InstalledExtension'] = IResolversParentTypes['InstalledExtension']> = {
  extension?: Resolver<Maybe<IResolversTypes['GalleryExtension']>, ParentType, ContextType>;
  identifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
  galleryIdentifier?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IIntegratedResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Integrated'] = IResolversParentTypes['Integrated']> = {
  setLocaleVariables?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  shellArgs?: Resolver<Maybe<IResolversTypes['ShellArgs']>, ParentType, ContextType>;
  shell?: Resolver<Maybe<IResolversTypes['Shell']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IJsonScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
  name: 'JSON';
}

export interface IJsonObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSONObject'], any> {
  name: 'JSONObject';
}

export type IKeyBindingResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['KeyBinding'] = IResolversParentTypes['KeyBinding']> = {
  command?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mac?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  linux?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  win?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IKeybindingContextMenuResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['KeybindingContextMenu'] = IResolversParentTypes['KeybindingContextMenu']> = {
  editItem?: Resolver<Maybe<IResolversTypes['EditKeybindingItem']>, ParentType, ContextType>;
  selectedItemIndex?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  editWhenIndex?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  newWhen?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isOpenDialog?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  search?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IKeybindingEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['KeybindingEditorInput'] = IResolversParentTypes['KeybindingEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IKeybindingItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['KeybindingItem'] = IResolversParentTypes['KeybindingItem']> = {
  command?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['KeybindingSource']>, ParentType, ContextType>;
  run?: Resolver<Maybe<IResolversTypes['ActionRun']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IKeybindingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Keybindings'] = IResolversParentTypes['Keybindings']> = {
  items?: Resolver<Maybe<Array<Maybe<IResolversTypes['KeybindingItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IKeyboardEvent_OutputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['KeyboardEvent_output'] = IResolversParentTypes['KeyboardEvent_output']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  key?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILableFormatTypeResolvers = EnumResolverSignature<{ default?: any, short?: any, medium?: any, long?: any }, IResolversTypes['LableFormatType']>;

export type ILanguageModeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['LanguageMode'] = IResolversParentTypes['LanguageMode']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILanguagesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Languages'] = IResolversParentTypes['Languages']> = {
  go?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  css?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  html?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  json?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  yaml?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  typescript?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  javascript?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILineMatchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['LineMatch'] = IResolversParentTypes['LineMatch']> = {
  preview?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  lineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  offsetAndLengths?: Resolver<Maybe<Array<Maybe<Array<Maybe<IResolversTypes['Int']>>>>>, ParentType, ContextType>;
  part?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILineRangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['LineRange'] = IResolversParentTypes['LineRange']> = {
  endColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endLine?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  startColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  startLine?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILocalUserSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['LocalUserSettings'] = IResolversParentTypes['LocalUserSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILocalizationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Localization'] = IResolversParentTypes['Localization']> = {
  languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  languageName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  localizedLanguageName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  translations?: Resolver<Maybe<Array<Maybe<IResolversTypes['LocalizationTranslation']>>>, ParentType, ContextType>;
  minimalTranslations?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILocalizationTranslationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['LocalizationTranslation'] = IResolversParentTypes['LocalizationTranslation']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ILocationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Location'] = IResolversParentTypes['Location']> = {
  __resolveType: TypeResolveFn<'ProvideTextDocumentLocationSignature', ParentType, ContextType>;
  rangeOrUri?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  uriRangeOrPosition?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  range?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
};

export type IMarkupContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MarkupContent'] = IResolversParentTypes['MarkupContent']> = {
  __resolveType: TypeResolveFn<null, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  kind?: Resolver<Maybe<IResolversTypes['MarkupKind']>, ParentType, ContextType>;
};

export type IMatchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Match'] = IResolversParentTypes['Match']> = {
  start?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  end?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMemorySettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MemorySettings'] = IResolversParentTypes['MemorySettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItem'] = IResolversParentTypes['MenuItem']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  run?: Resolver<Maybe<IResolversTypes['ActionRun']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemAction'] = IResolversParentTypes['MenuItemAction']> = {
  action?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionContextResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionContext'] = IResolversParentTypes['MenuItemActionContext']> = {
  context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionDebugResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionDebug'] = IResolversParentTypes['MenuItemActionDebug']> = {
  callstack?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
  toolbar?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionEditorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionEditor'] = IResolversParentTypes['MenuItemActionEditor']> = {
  context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['MenuItemActionEditorTitle']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionEditorTitleResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionEditorTitle'] = IResolversParentTypes['MenuItemActionEditorTitle']> = {
  own?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionScmResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionScm'] = IResolversParentTypes['MenuItemActionScm']> = {
  title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  resourceGroup?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
  change?: Resolver<Maybe<IResolversTypes['MenuItemActionScmChange']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionScmChangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionScmChange'] = IResolversParentTypes['MenuItemActionScmChange']> = {
  title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenuItemActionViewResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MenuItemActionView'] = IResolversParentTypes['MenuItemActionView']> = {
  title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  item?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMenusResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Menus'] = IResolversParentTypes['Menus']> = {
  commandPalette?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  explorer?: Resolver<Maybe<IResolversTypes['MenuItemActionContext']>, ParentType, ContextType>;
  editor?: Resolver<Maybe<IResolversTypes['MenuItemActionEditor']>, ParentType, ContextType>;
  debug?: Resolver<Maybe<IResolversTypes['MenuItemActionDebug']>, ParentType, ContextType>;
  scm?: Resolver<Maybe<IResolversTypes['MenuItemActionScm']>, ParentType, ContextType>;
  view?: Resolver<Maybe<IResolversTypes['MenuItemActionView']>, ParentType, ContextType>;
  touchBar?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMergeGroupModeResolvers = EnumResolverSignature<{ COPY_EDITORS?: any, MOVE_EDITORS?: any }, IResolversTypes['MergeGroupMode']>;

export type IMessageBoxOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MessageBoxOptions'] = IResolversParentTypes['MessageBoxOptions']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  buttons?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  defaultId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  detail?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  checkboxLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  checkboxChecked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  cancelId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  noLink?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  normalizeAccessKeys?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMessageBoxResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MessageBoxResult'] = IResolversParentTypes['MessageBoxResult']> = {
  button?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  checkboxChecked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMessageLinkResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['MessageLink'] = IResolversParentTypes['MessageLink']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  href?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  offset?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  length?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMutationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
  activate?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationActivateArgs, 'request'>>;
  activateEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationActivateEditorArgs, never>>;
  addEntry?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationAddEntryArgs, never>>;
  addFolders?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationAddFoldersArgs, never>>;
  addNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationAddNotificationArgs, never>>;
  canHandleResource?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationCanHandleResourceArgs, 'resource'>>;
  changeEdit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationChangeEditArgs, never>>;
  changeKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationChangeKeybindingArgs, never>>;
  changeWhenExpression?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationChangeWhenExpressionArgs, never>>;
  changeWorkspace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationChangeWorkspaceArgs, never>>;
  clearSearchCache?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationClearSearchCacheArgs, never>>;
  closeAllEditors?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  closeDialog?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  closeEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationCloseEditorArgs, never>>;
  closeEditors?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationCloseEditorsArgs, never>>;
  closeNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationCloseNotificationArgs, never>>;
  codeLenseProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationCodeLenseProviderDefinitionArgs, never>>;
  completionProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationCompletionProviderDefinitionArgs, never>>;
  copy?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationCopyArgs, never>>;
  copyFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationCopyFileArgs, 'source' | 'target'>>;
  createExtension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType, RequireFields<IMutationCreateExtensionArgs, 'publisher' | 'name'>>;
  createFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationCreateFileArgs, 'resource'>>;
  createFolder?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationCreateFolderArgs, 'resource'>>;
  createTextFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationCreateTextFileArgs, 'resource'>>;
  createUntitledFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationCreateUntitledFileArgs, never>>;
  definitionDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationDefinitionDefinitionArgs, never>>;
  del?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationDelArgs, 'resource'>>;
  deleteExtension?: Resolver<IResolversTypes['EmptyResponse'], ParentType, ContextType, RequireFields<IMutationDeleteExtensionArgs, 'extension'>>;
  deleteTextFile?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationDeleteTextFileArgs, 'resource'>>;
  documentFormattingProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationDocumentFormattingProviderDefinitionArgs, never>>;
  documentHighLightProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationDocumentHighLightProviderDefinitionArgs, never>>;
  documentSymbolDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationDocumentSymbolDefinitionArgs, never>>;
  dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  editKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationEditKeybindingArgs, never>>;
  findFileStat?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationFindFileStatArgs, 'resource'>>;
  getConfigurationTarget?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType, RequireFields<IMutationGetConfigurationTargetArgs, never>>;
  getEditorState?: Resolver<Maybe<IResolversTypes['CodeEditorViewState']>, ParentType, ContextType, RequireFields<IMutationGetEditorStateArgs, 'editorId' | 'resource'>>;
  getFilesTreeData?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileStatWithMetadata']>>>, ParentType, ContextType, RequireFields<IMutationGetFilesTreeDataArgs, 'resource'>>;
  gotoLine?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationGotoLineArgs, never>>;
  handler?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationHandlerArgs, never>>;
  hideContextMenu?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hideInputModel?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hideKeybindingDialog?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  highlightLine?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationHighlightLineArgs, never>>;
  hoverProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationHoverProviderDefinitionArgs, never>>;
  install?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType, RequireFields<IMutationInstallArgs, 'vsix'>>;
  jsonWrite?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationJsonWriteArgs, never>>;
  keepOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationKeepOpenArgs, never>>;
  loadFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationLoadFileArgs, 'resource'>>;
  loadFileContent?: Resolver<Maybe<IResolversTypes['FileContent']>, ParentType, ContextType, RequireFields<IMutationLoadFileContentArgs, 'resource'>>;
  loadFileWithContent?: Resolver<Maybe<IResolversTypes['TextFileContent']>, ParentType, ContextType, RequireFields<IMutationLoadFileWithContentArgs, 'resource'>>;
  loadFilesTreeData?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileStatWithMetadata']>>>, ParentType, ContextType, RequireFields<IMutationLoadFilesTreeDataArgs, 'resource'>>;
  lookupKeybinding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType, RequireFields<IMutationLookupKeybindingArgs, never>>;
  makePinEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationMakePinEditorArgs, never>>;
  moveEditorInsideGroup?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationMoveEditorInsideGroupArgs, never>>;
  moveFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationMoveFileArgs, 'source' | 'target'>>;
  moveTextFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationMoveTextFileArgs, 'source' | 'target'>>;
  notify?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationNotifyArgs, never>>;
  notifyError?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationNotifyErrorArgs, never>>;
  notifyInfo?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationNotifyInfoArgs, never>>;
  notifyPrompt?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationNotifyPromptArgs, never>>;
  notifyWarn?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationNotifyWarnArgs, never>>;
  openEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenEditorArgs, 'content'>>;
  openEditorWithResourceDiffInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenEditorWithResourceDiffInputArgs, 'editor'>>;
  openEditorWithResourceInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenEditorWithResourceInputArgs, 'editor'>>;
  openEditorWithResourceSideBySideInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenEditorWithResourceSideBySideInputArgs, 'editor'>>;
  openEditorWithUntitledResourceInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenEditorWithUntitledResourceInputArgs, 'editor'>>;
  openFile?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenFileArgs, 'content'>>;
  openGlobalKeybindingSettings?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenGlobalKeybindingSettingsArgs, never>>;
  openLanguageDocument?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationOpenLanguageDocumentArgs, never>>;
  openPreferenceSettings?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationOpenPreferenceSettingsArgs, never>>;
  publishExtension?: Resolver<IResolversTypes['ExtensionRegistryPublishExtensionResult'], ParentType, ContextType, RequireFields<IMutationPublishExtensionArgs, 'extensionID' | 'manifest' | 'force'>>;
  readTextFile?: Resolver<Maybe<IResolversTypes['TextFileContent']>, ParentType, ContextType, RequireFields<IMutationReadTextFileArgs, 'resource'>>;
  referenceProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationReferenceProviderDefinitionArgs, never>>;
  registerKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRegisterKeybindingArgs, never>>;
  removeChangedContent?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveChangedContentArgs, 'resource'>>;
  removeEdit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveEditArgs, never>>;
  removeExtension?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveExtensionArgs, 'id'>>;
  removeFolders?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveFoldersArgs, never>>;
  removeKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveKeybindingArgs, never>>;
  removeStatusbarEntry?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveStatusbarEntryArgs, 'id'>>;
  rename?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationRenameArgs, 'resource' | 'target'>>;
  renameDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationRenameDefinitionArgs, never>>;
  replaceContent?: Resolver<Maybe<IResolversTypes['ReplaceContentResult']>, ParentType, ContextType, RequireFields<IMutationReplaceContentArgs, never>>;
  resetKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationResetKeybindingArgs, never>>;
  resetSetting?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationResetSettingArgs, never>>;
  resolveKeyboardEvent?: Resolver<Maybe<IResolversTypes['KeyboardEvent_output']>, ParentType, ContextType, RequireFields<IMutationResolveKeyboardEventArgs, never>>;
  runMenuAction?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRunMenuActionArgs, never>>;
  saveAllEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSaveAllEditorArgs, never>>;
  saveFile?: Resolver<Maybe<IResolversTypes['FileStat']>, ParentType, ContextType, RequireFields<IMutationSaveFileArgs, 'resource' | 'options'>>;
  saveFileAs?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType, RequireFields<IMutationSaveFileAsArgs, 'resource' | 'options'>>;
  saveUserSettings?: Resolver<Maybe<IResolversTypes['SaveWorkspaceRes']>, ParentType, ContextType, RequireFields<IMutationSaveUserSettingsArgs, never>>;
  saveWorkspaceSettings?: Resolver<Maybe<IResolversTypes['SaveWorkspaceRes']>, ParentType, ContextType>;
  searchKeybinding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSearchKeybindingArgs, never>>;
  selectEdit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSelectEditArgs, never>>;
  setEncoding?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSetEncodingArgs, 'resource'>>;
  setFilesTreeData?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSetFilesTreeDataArgs, never>>;
  setSelected?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSetSelectedArgs, never>>;
  setSelectedKeybindingIndex?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSetSelectedKeybindingIndexArgs, never>>;
  setStatusMessage?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType, RequireFields<IMutationSetStatusMessageArgs, never>>;
  show?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationShowArgs, never>>;
  showContextMenu?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationShowContextMenuArgs, never>>;
  showInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationShowInputArgs, never>>;
  showPickInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationShowPickInputArgs, never>>;
  startExtensionHost?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationStartExtensionHostArgs, never>>;
  stopEditWhenExpression?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  switchSettings?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationSwitchSettingsArgs, never>>;
  testNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  textSearch_?: Resolver<Maybe<IResolversTypes['SearchComplete']>, ParentType, ContextType, RequireFields<IMutationTextSearch_Args, never>>;
  unwatch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUnwatchArgs, 'resource' | 'session'>>;
  unwatchFileChanges?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUnwatchFileChangesArgs, 'resource' | 'session'>>;
  updateChangedContent?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateChangedContentArgs, 'resource' | 'changedEvent'>>;
  updateConfigurationValue?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateConfigurationValueArgs, 'key' | 'value'>>;
  updateContent?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationUpdateContentArgs, 'resource' | 'value' | 'options'>>;
  updateContext?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateContextArgs, never>>;
  updateEditorState?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateEditorStateArgs, 'editorId' | 'resource' | 'state'>>;
  updateExtension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType, RequireFields<IMutationUpdateExtensionArgs, 'extension'>>;
  updateFileDirtyState?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateFileDirtyStateArgs, 'resource' | 'isFileDirty'>>;
  updateFolders?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateFoldersArgs, never>>;
  updateLayout?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateLayoutArgs, never>>;
  updateModel?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateModelArgs, never>>;
  updateSelectedResource?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateSelectedResourceArgs, 'resource'>>;
  updateStatusbarEntry?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateStatusbarEntryArgs, never>>;
  updateWorkspaceContextAddFolders?: Resolver<Maybe<Array<Maybe<IResolversTypes['WorkspaceFolderData']>>>, ParentType, ContextType, RequireFields<IMutationUpdateWorkspaceContextAddFoldersArgs, never>>;
  updateWorkspaceContextRemoveFolders?: Resolver<Maybe<Array<Maybe<IResolversTypes['WorkspaceFolderData']>>>, ParentType, ContextType, RequireFields<IMutationUpdateWorkspaceContextRemoveFoldersArgs, never>>;
  updateWorkspaceContextUpdateFolders?: Resolver<Maybe<Array<Maybe<IResolversTypes['WorkspaceFolderData']>>>, ParentType, ContextType, RequireFields<IMutationUpdateWorkspaceContextUpdateFoldersArgs, never>>;
  watchFile?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType, RequireFields<IMutationWatchFileArgs, 'resource'>>;
  watchFileChanges?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationWatchFileChangesArgs, 'resource' | 'options'>>;
  writeChunk?: Resolver<Maybe<IResolversTypes['UpdatedResource']>, ParentType, ContextType, RequireFields<IMutationWriteChunkArgs, 'resource' | 'changes' | 'options'>>;
  writeChunkWithDelay?: Resolver<Maybe<IResolversTypes['UpdateDelayedResource']>, ParentType, ContextType, RequireFields<IMutationWriteChunkWithDelayArgs, 'resource' | 'changes' | 'options'>>;
  writeContent?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  writeTextFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IMutationWriteTextFileArgs, 'resource' | 'value' | 'options'>>;
};

export type INativeOpenDialogOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NativeOpenDialogOptions'] = IResolversParentTypes['NativeOpenDialogOptions']> = {
  windowId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  forceNewWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  defaultPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  telemetryEventName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INewWindowOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NewWindowOptions'] = IResolversParentTypes['NewWindowOptions']> = {
  remoteAuthority?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  reuseWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INodeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Node'] = IResolversParentTypes['Node']> = {
  __resolveType: TypeResolveFn<'RegistryExtension', ParentType, ContextType>;
  id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
};

export type INotificationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Notification'] = IResolversParentTypes['Notification']> = {
  index?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  severity?: Resolver<Maybe<IResolversTypes['NotificationSeverity']>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  actions?: Resolver<Maybe<IResolversTypes['NotificationActions']>, ParentType, ContextType>;
  sticky?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationActionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationActions'] = IResolversParentTypes['NotificationActions']> = {
  primary?: Resolver<Maybe<Array<Maybe<IResolversTypes['Action']>>>, ParentType, ContextType>;
  secondary?: Resolver<Maybe<Array<Maybe<IResolversTypes['Action']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationChangeEventResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationChangeEvent'] = IResolversParentTypes['NotificationChangeEvent']> = {
  index?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  item?: Resolver<Maybe<IResolversTypes['NotificationViewItem']>, ParentType, ContextType>;
  kind?: Resolver<Maybe<IResolversTypes['NotificationChangeType']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationMessageResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationMessage'] = IResolversParentTypes['NotificationMessage']> = {
  raw?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  original?: Resolver<Maybe<IResolversTypes['NotificationMessage']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  links?: Resolver<Maybe<Array<Maybe<IResolversTypes['MessageLink']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationSeverityResolvers = EnumResolverSignature<{ Ignore?: any, Info?: any, Warning?: any, Error?: any }, IResolversTypes['NotificationSeverity']>;

export type INotificationViewItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationViewItem'] = IResolversParentTypes['NotificationViewItem']> = {
  severity?: Resolver<Maybe<IResolversTypes['NotificationSeverity']>, ParentType, ContextType>;
  sticky?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  silent?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['NotificationMessage']>, ParentType, ContextType>;
  source?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  action?: Resolver<Maybe<IResolversTypes['NotificationActions']>, ParentType, ContextType>;
  progress?: Resolver<Maybe<IResolversTypes['NotificationViewItemProgress']>, ParentType, ContextType>;
  expanded?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canCollapse?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationViewItemProgressResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationViewItemProgress'] = IResolversParentTypes['NotificationViewItemProgress']> = {
  state?: Resolver<Maybe<IResolversTypes['NotificationViewItemProgressState']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationViewItemProgressStateResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['NotificationViewItemProgressState'] = IResolversParentTypes['NotificationViewItemProgressState']> = {
  infinite?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  worked?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  done?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type INotificationsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Notifications'] = IResolversParentTypes['Notifications']> = {
  notifications?: Resolver<Maybe<Array<Maybe<IResolversTypes['Notification']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IObservableScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Observable'], any> {
  name: 'Observable';
}

export type IOneSearchPathPatternResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['OneSearchPathPattern'] = IResolversParentTypes['OneSearchPathPattern']> = {
  searchPath?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  pattern?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOpenConfigurationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['OpenConfiguration'] = IResolversParentTypes['OpenConfiguration']> = {
  context?: Resolver<Maybe<IResolversTypes['OpenContext']>, ParentType, ContextType>;
  contextWindowId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  cli?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  userEnv?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  urisToOpen?: Resolver<Maybe<Array<Maybe<IResolversTypes['URIToOpen']>>>, ParentType, ContextType>;
  waitMarkerFileURI?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  preferNewWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  forceNewWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  forceNewTabbedWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  forceReuseWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  forceEmpty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  diffMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  addMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  initialStartup?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  noRecentEntry?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOpenDialogOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['OpenDialogOptions'] = IResolversParentTypes['OpenDialogOptions']> = {
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  defaultPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  buttonLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  filters?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileFilter']>>>, ParentType, ContextType>;
  properties?: Resolver<Maybe<Array<Maybe<IResolversTypes['OpenDialogOptionsProperties']>>>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOpenFileRequestResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['OpenFileRequest'] = IResolversParentTypes['OpenFileRequest']> = {
  filesToOpenOrCreate?: Resolver<Maybe<Array<Maybe<IResolversTypes['IPathData']>>>, ParentType, ContextType>;
  filesToDiff?: Resolver<Maybe<Array<Maybe<IResolversTypes['IPathData']>>>, ParentType, ContextType>;
  filesToWait?: Resolver<Maybe<IResolversTypes['IPathsToWaitForData']>, ParentType, ContextType>;
  termProgram?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOpenPositioningTypeResolvers = EnumResolverSignature<{ left?: any, right?: any, first?: any, last?: any }, IResolversTypes['OpenPositioningType']>;

export type IOpenSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['OpenSettings'] = IResolversParentTypes['OpenSettings']> = {
  forceNewWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  forceReuseWindow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  diffMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  addMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  noRecentEntry?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  waitMarkerFileURI?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  args?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOpenSideBySideDirectionResolvers = EnumResolverSignature<{ right?: any, down?: any }, IResolversTypes['OpenSideBySideDirection']>;

export type IOutputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Output'] = IResolversParentTypes['Output']> = {
  maxChannelHistory?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IOverridesResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Overrides'] = IResolversParentTypes['Overrides']> = {
  contents?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  identifiers?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPageInfoResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PageInfo'] = IResolversParentTypes['PageInfo']> = {
  hasNextPage?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPathResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Path'] = IResolversParentTypes['Path']> = {
  lineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  columnNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  exists?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPathsToWaitForResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PathsToWaitFor'] = IResolversParentTypes['PathsToWaitFor']> = {
  paths?: Resolver<Maybe<Array<Maybe<IResolversTypes['Path']>>>, ParentType, ContextType>;
  waitMarkerFileUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPatternInfoResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PatternInfo'] = IResolversParentTypes['PatternInfo']> = {
  pattern?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  isRegExp?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isWordMatch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  wordSeparators?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isMultiline?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isCaseSensitive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isSmartCase?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPendingStatusbarEntryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PendingStatusbarEntry'] = IResolversParentTypes['PendingStatusbarEntry']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPositionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Position'] = IResolversParentTypes['Position']> = {
  lineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  column?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  line?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  character?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPreferenceItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PreferenceItem'] = IResolversParentTypes['PreferenceItem']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  default?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  categoryType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  settings?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enum?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  enumDescriptions?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPreferencesEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PreferencesEditorInput'] = IResolversParentTypes['PreferencesEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  master?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  details?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPreferencesTypeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PreferencesType'] = IResolversParentTypes['PreferencesType']> = {
  type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  data?: Resolver<Maybe<Array<Maybe<IResolversTypes['Setting']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IPrimaryButtonActionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['PrimaryButtonAction'] = IResolversParentTypes['PrimaryButtonAction']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  run?: Resolver<Maybe<IResolversTypes['ActionRun']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IProcessMonitoringResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ProcessMonitoring'] = IResolversParentTypes['ProcessMonitoring']> = {
  cpu?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  memory?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IProgressResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Progress'] = IResolversParentTypes['Progress']> = {
  total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  worked?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IProvideTextDocumentLocationSignatureResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ProvideTextDocumentLocationSignature'] = IResolversParentTypes['ProvideTextDocumentLocationSignature']> = {
  textDocument?: Resolver<Maybe<IResolversTypes['TextDocumentIdentifier']>, ParentType, ContextType>;
  position?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  rangeOrUri?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  uriRangeOrPosition?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  range?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQueryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
  contextMenu?: Resolver<Maybe<IResolversTypes['ContextMenu']>, ParentType, ContextType>;
  defaultPreferences?: Resolver<Maybe<IResolversTypes['DefaultPreferencesResponse']>, ParentType, ContextType>;
  defaultSetting?: Resolver<Maybe<IResolversTypes['Setting']>, ParentType, ContextType>;
  defaultViewerSettingsSubject?: Resolver<IResolversTypes['DefaultSettings'], ParentType, ContextType, RequireFields<IQueryDefaultViewerSettingsSubjectArgs, never>>;
  dialog?: Resolver<Maybe<IResolversTypes['Dialog']>, ParentType, ContextType>;
  docSitePage?: Resolver<Maybe<IResolversTypes['DocSitePage']>, ParentType, ContextType, RequireFields<IQueryDocSitePageArgs, 'path'>>;
  editorPart?: Resolver<Maybe<IResolversTypes['EditorPart']>, ParentType, ContextType>;
  editorState?: Resolver<Maybe<IResolversTypes['CodeEditorViewState']>, ParentType, ContextType, RequireFields<IQueryEditorStateArgs, 'editorId' | 'resource'>>;
  existsFile?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IQueryExistsFileArgs, 'resource'>>;
  extension?: Resolver<Maybe<IResolversTypes['RegistryExtension']>, ParentType, ContextType, RequireFields<IQueryExtensionArgs, 'extensionID'>>;
  extensionRegistry?: Resolver<IResolversTypes['ExtensionRegistry'], ParentType, ContextType>;
  extensions?: Resolver<IResolversTypes['RegistryExtensionConnection'], ParentType, ContextType, RequireFields<IQueryExtensionsArgs, 'local' | 'remote' | 'includeWIP'>>;
  fileSearch?: Resolver<Maybe<IResolversTypes['SearchComplete']>, ParentType, ContextType, RequireFields<IQueryFileSearchArgs, never>>;
  gallery?: Resolver<Maybe<IResolversTypes['GalleryPager']>, ParentType, ContextType, RequireFields<IQueryGalleryArgs, never>>;
  galleryExtension?: Resolver<Maybe<IResolversTypes['GalleryExtension']>, ParentType, ContextType, RequireFields<IQueryGalleryExtensionArgs, 'extensionID'>>;
  getChangedEvent?: Resolver<Maybe<IResolversTypes['IContentChangedEvent']>, ParentType, ContextType, RequireFields<IQueryGetChangedEventArgs, 'resource'>>;
  getConfigurationData?: Resolver<Maybe<IResolversTypes['ConfigurationData']>, ParentType, ContextType>;
  getConfigurationTarget?: Resolver<Maybe<IResolversTypes['ConfigurationScope']>, ParentType, ContextType>;
  getContextData?: Resolver<Maybe<IResolversTypes['Context']>, ParentType, ContextType>;
  getContextProperty?: Resolver<Maybe<IResolversTypes['Context']>, ParentType, ContextType, RequireFields<IQueryGetContextPropertyArgs, never>>;
  getDefaultSettings?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType, RequireFields<IQueryGetDefaultSettingsArgs, never>>;
  getDefaultSettingsResource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType, RequireFields<IQueryGetDefaultSettingsResourceArgs, never>>;
  getEnvironment?: Resolver<Maybe<IResolversTypes['Environment']>, ParentType, ContextType>;
  getKeybindings?: Resolver<Maybe<IResolversTypes['Keybindings']>, ParentType, ContextType>;
  getMostCommonlyUsedSettings?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  getSelectedValue?: Resolver<Maybe<IResolversTypes['SelectedOutput']>, ParentType, ContextType>;
  getViews?: Resolver<Maybe<Array<Maybe<IResolversTypes['ViewDescriptor']>>>, ParentType, ContextType, RequireFields<IQueryGetViewsArgs, 'containerId'>>;
  getWorkspace?: Resolver<Maybe<IResolversTypes['WorkspaceData']>, ParentType, ContextType>;
  getWorkspaceFolderContext?: Resolver<Maybe<IResolversTypes['WorkspaceData']>, ParentType, ContextType, RequireFields<IQueryGetWorkspaceFolderContextArgs, never>>;
  getWorkspaceValue?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType, RequireFields<IQueryGetWorkspaceValueArgs, never>>;
  gotoLineQuickAccess?: Resolver<Maybe<IResolversTypes['GoToLineQuickAccess']>, ParentType, ContextType>;
  installed?: Resolver<Maybe<Array<Maybe<IResolversTypes['InstalledExtension']>>>, ParentType, ContextType>;
  instances?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionInstance']>>>, ParentType, ContextType>;
  keybindingContextMenu?: Resolver<Maybe<IResolversTypes['KeybindingContextMenu']>, ParentType, ContextType>;
  keybindings?: Resolver<Maybe<IResolversTypes['Keybindings']>, ParentType, ContextType>;
  node?: Resolver<Maybe<IResolversTypes['Node']>, ParentType, ContextType, RequireFields<IQueryNodeArgs, 'id'>>;
  notifications?: Resolver<Maybe<IResolversTypes['Notifications']>, ParentType, ContextType>;
  quickInputModel?: Resolver<Maybe<IResolversTypes['QuickInputModel']>, ParentType, ContextType>;
  readStreamTextFile?: Resolver<Maybe<IResolversTypes['TextFileStreamContent']>, ParentType, ContextType, RequireFields<IQueryReadStreamTextFileArgs, 'resource'>>;
  readStringStreamTextFile?: Resolver<Maybe<IResolversTypes['TextFilePublishContent']>, ParentType, ContextType, RequireFields<IQueryReadStringStreamTextFileArgs, 'resource'>>;
  readTextFile?: Resolver<Maybe<IResolversTypes['TextFileContent']>, ParentType, ContextType, RequireFields<IQueryReadTextFileArgs, 'resource'>>;
  registerProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IQueryRegisterProviderArgs, never>>;
  releases?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionRelease']>>>, ParentType, ContextType, RequireFields<IQueryReleasesArgs, 'extensionID'>>;
  resolveContent?: Resolver<Maybe<IResolversTypes['FileContent']>, ParentType, ContextType, RequireFields<IQueryResolveContentArgs, 'resource'>>;
  resolveContents?: Resolver<Maybe<Array<Maybe<IResolversTypes['ResolveFileResultWithMetadata']>>>, ParentType, ContextType, RequireFields<IQueryResolveContentsArgs, never>>;
  resolveFile?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType, RequireFields<IQueryResolveFileArgs, 'resource'>>;
  resolveFileContent?: Resolver<Maybe<IResolversTypes['TextFileContent']>, ParentType, ContextType, RequireFields<IQueryResolveFileContentArgs, 'resource'>>;
  resolveUntitledFileContent?: Resolver<Maybe<IResolversTypes['TextFileContent']>, ParentType, ContextType, RequireFields<IQueryResolveUntitledFileContentArgs, 'resource'>>;
  selectedResource?: Resolver<Maybe<IResolversTypes['Context']>, ParentType, ContextType>;
  settingsSubject?: Resolver<Maybe<IResolversTypes['ISettingsSubject']>, ParentType, ContextType, RequireFields<IQuerySettingsSubjectArgs, 'id'>>;
  showDialog?: Resolver<Maybe<IResolversTypes['DialogResult']>, ParentType, ContextType, RequireFields<IQueryShowDialogArgs, never>>;
  showNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IQueryShowNotificationArgs, never>>;
  statusbar?: Resolver<Maybe<IResolversTypes['Statusbar']>, ParentType, ContextType>;
  statusbarItem?: Resolver<Maybe<IResolversTypes['StatusbarItem']>, ParentType, ContextType, RequireFields<IQueryStatusbarItemArgs, never>>;
  textSearch?: Resolver<Maybe<IResolversTypes['SearchComplete']>, ParentType, ContextType, RequireFields<IQueryTextSearchArgs, never>>;
  treeViewData?: Resolver<Maybe<Array<Maybe<IResolversTypes['TreeItem']>>>, ParentType, ContextType>;
  untitledResources?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  userPreferences?: Resolver<Maybe<IResolversTypes['UserPreferencesRes']>, ParentType, ContextType, RequireFields<IQueryUserPreferencesArgs, never>>;
  viewerSettings?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  workspaces?: Resolver<Maybe<Array<Maybe<IResolversTypes['WorkspaceRes']>>>, ParentType, ContextType>;
};

export type IQuickInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['QuickInput'] = IResolversParentTypes['QuickInput']> = {
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  step?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  totalSteps?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  ignoreFocusOut?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  placeholder?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  prompt?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  validationMessage?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQuickInputModelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['QuickInputModel'] = IResolversParentTypes['QuickInputModel']> = {
  show?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  input?: Resolver<Maybe<IResolversTypes['QuickInput']>, ParentType, ContextType>;
  quickPick?: Resolver<Maybe<IResolversTypes['QuickPick']>, ParentType, ContextType>;
  inputValue?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  selectedValue?: Resolver<Maybe<Array<Maybe<IResolversTypes['QuickPickItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQuickPickResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['QuickPick'] = IResolversParentTypes['QuickPick']> = {
  placeholder?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  canSelectMany?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  autoFocusOnList?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  items?: Resolver<Maybe<Array<Maybe<IResolversTypes['QuickPickItem']>>>, ParentType, ContextType>;
  activeItem?: Resolver<Maybe<IResolversTypes['QuickPickItem']>, ParentType, ContextType>;
  selectedItems?: Resolver<Maybe<Array<Maybe<IResolversTypes['QuickPickItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQuickPickItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['QuickPickItem'] = IResolversParentTypes['QuickPickItem']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  detail?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  keybinding?: Resolver<Maybe<IResolversTypes['KeybindingItem']>, ParentType, ContextType>;
  italic?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  highlights?: Resolver<Maybe<IResolversTypes['QuickPickItemHighlights']>, ParentType, ContextType>;
  picked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  alwaysShow?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQuickPickItemHighlightsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['QuickPickItemHighlights'] = IResolversParentTypes['QuickPickItemHighlights']> = {
  label?: Resolver<Maybe<Array<Maybe<IResolversTypes['Match']>>>, ParentType, ContextType>;
  description?: Resolver<Maybe<Array<Maybe<IResolversTypes['Match']>>>, ParentType, ContextType>;
  detail?: Resolver<Maybe<Array<Maybe<IResolversTypes['Match']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Range'] = IResolversParentTypes['Range']> = {
  start?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  end?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  startLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  startColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRegistryEntryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RegistryEntry'] = IResolversParentTypes['RegistryEntry']> = {
  registrationOptions?: Resolver<Maybe<IResolversTypes['TextDocumentRegistrationOptions']>, ParentType, ContextType>;
  provider?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRegistryExtensionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RegistryExtension'] = IResolversParentTypes['RegistryExtension']> = {
  id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
  uuid?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  publisher?: Resolver<Maybe<IResolversTypes['RegistryPublisher']>, ParentType, ContextType>;
  extensionID?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  extensionIDWithoutRegistry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  version?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  activationEvents?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  manifest?: Resolver<Maybe<IResolversTypes['ExtensionManifest']>, ParentType, ContextType>;
  updatedAt?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  remoteURL?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isLocal?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  viewerCanAdminister?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  releases?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionRelease']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRegistryExtensionConnectionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RegistryExtensionConnection'] = IResolversParentTypes['RegistryExtensionConnection']> = {
  nodes?: Resolver<Array<IResolversTypes['RegistryExtension']>, ParentType, ContextType>;
  totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  pageInfo?: Resolver<IResolversTypes['PageInfo'], ParentType, ContextType>;
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  error?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRegistryPublisherResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RegistryPublisher'] = IResolversParentTypes['RegistryPublisher']> = {
  UserId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRegistryPublisherConnectionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RegistryPublisherConnection'] = IResolversParentTypes['RegistryPublisherConnection']> = {
  nodes?: Resolver<Array<IResolversTypes['RegistryPublisher']>, ParentType, ContextType>;
  totalCount?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  pageInfo?: Resolver<IResolversTypes['PageInfo'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRemoteUserSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RemoteUserSettings'] = IResolversParentTypes['RemoteUserSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IReplaceContentResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ReplaceContentResult'] = IResolversParentTypes['ReplaceContentResult']> = {
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  oldText?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  newText?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResolveFileResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ResolveFileResult'] = IResolversParentTypes['ResolveFileResult']> = {
  stat?: Resolver<Maybe<IResolversTypes['FileStat']>, ParentType, ContextType>;
  success?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['VSBufferReadableStream']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResolveFileResultWithMetadataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ResolveFileResultWithMetadata'] = IResolversParentTypes['ResolveFileResultWithMetadata']> = {
  stat?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  success?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResourceEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ResourceEditorInput'] = IResolversParentTypes['ResourceEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResourceEncodingResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ResourceEncoding'] = IResolversParentTypes['ResourceEncoding']> = {
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  hasBOM?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResourceMapConfigurationModelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ResourceMapConfigurationModel'] = IResolversParentTypes['ResourceMapConfigurationModel']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  contents?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  keys?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  overrides?: Resolver<Maybe<IResolversTypes['ConfigurationOverrides']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRevealOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RevealOptions'] = IResolversParentTypes['RevealOptions']> = {
  select?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  focus?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  expand?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRunActionInWindowRequestResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RunActionInWindowRequest'] = IResolversParentTypes['RunActionInWindowRequest']> = {
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  from?: Resolver<Maybe<IResolversTypes['RunActionInWindowRequestFrom']>, ParentType, ContextType>;
  args?: Resolver<Maybe<Array<Maybe<IResolversTypes['AnyObject']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IRunKeybindingInWindowRequestResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['RunKeybindingInWindowRequest'] = IResolversParentTypes['RunKeybindingInWindowRequest']> = {
  userSettingsLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISaveDialogOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SaveDialogOptions'] = IResolversParentTypes['SaveDialogOptions']> = {
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  defaultPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  buttonLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  filters?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileFilter']>>>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  nameFieldLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  showTagField?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISaveWorkspaceResResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SaveWorkspaceRes'] = IResolversParentTypes['SaveWorkspaceRes']> = {
  updated?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IScriptsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Scripts'] = IResolversParentTypes['Scripts']> = {
  cdebasebuild?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  cdebasepublish?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Search'] = IResolversParentTypes['Search']> = {
  location?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  smartCase?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  useRipgrep?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  useIgnoreFiles?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  followSymlinks?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  globalFindClipboard?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  quickOpen?: Resolver<Maybe<IResolversTypes['SearchQuickOpen']>, ParentType, ContextType>;
  exclude?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchCompleteResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchComplete'] = IResolversParentTypes['SearchComplete']> = {
  limitHit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  stats?: Resolver<IResolversTypes['SearchCompleteStatsStats'], ParentType, ContextType>;
  results?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileMatch']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchCompleteStatsStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchCompleteStatsStats'] = IResolversParentTypes['SearchCompleteStatsStats']> = {
  __resolveType: TypeResolveFn<'FileSearchStats' | 'TextSearchStats', ParentType, ContextType>;
};

export type ISearchCompleteStreamResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchCompleteStream'] = IResolversParentTypes['SearchCompleteStream']> = {
  isEnd?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  limitHit?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  results?: Resolver<Maybe<Array<Maybe<IResolversTypes['FileMatch']>>>, ParentType, ContextType>;
  stats?: Resolver<IResolversTypes['SearchCompleteStatsStats'], ParentType, ContextType>;
  part?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchEngineStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchEngineStats'] = IResolversParentTypes['SearchEngineStats']> = {
  traversal?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  fileWalkTime?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  directoriesWalked?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  filesWalked?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  cmdTime?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  cmdResultCount?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchLogResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchLog'] = IResolversParentTypes['SearchLog']> = {
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchPathPatternResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchPathPattern'] = IResolversParentTypes['SearchPathPattern']> = {
  searchPath?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  pattern?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchProgressItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchProgressItem'] = IResolversParentTypes['SearchProgressItem']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  results?: Resolver<Maybe<Array<Maybe<IResolversTypes['TextSearchResult']>>>, ParentType, ContextType>;
  total?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  worked?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  message?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchQuickOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchQuickOpen'] = IResolversParentTypes['SearchQuickOpen']> = {
  includeSymbols?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISearchRangeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SearchRange'] = IResolversParentTypes['SearchRange']> = {
  startLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  startColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endLineNumber?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  endColumn?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISelectedOutputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SelectedOutput'] = IResolversParentTypes['SelectedOutput']> = {
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  inputValue?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  selectedValue?: Resolver<Maybe<Array<Maybe<IResolversTypes['QuickPickItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISelectionStatusResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SelectionStatus'] = IResolversParentTypes['SelectionStatus']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Setting'] = IResolversParentTypes['Setting']> = {
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  range?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  keyRange?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  default?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  valueRange?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  description?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  descriptionIsMarkdown?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  descriptionRanges?: Resolver<Maybe<Array<Maybe<IResolversTypes['Range']>>>, ParentType, ContextType>;
  overrides?: Resolver<Maybe<Array<Maybe<IResolversTypes['Setting']>>>, ParentType, ContextType>;
  overrideOf?: Resolver<Maybe<IResolversTypes['Setting']>, ParentType, ContextType>;
  deprecationMessage?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  scope?: Resolver<Maybe<IResolversTypes['ConfigurationScope']>, ParentType, ContextType>;
  type?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  enum?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  enumDescriptions?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  enumDescriptionsAreMarkdown?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  extensionInfo?: Resolver<Maybe<IResolversTypes['ConfigurationExtensionInfo']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Settings'] = IResolversParentTypes['Settings']> = {
  createdAt?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  contents?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingsCascadeResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SettingsCascade'] = IResolversParentTypes['SettingsCascade']> = {
  subjects?: Resolver<Maybe<Array<Maybe<IResolversTypes['SettingsSubject']>>>, ParentType, ContextType>;
  final?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  finalConfiguration?: Resolver<Maybe<IResolversTypes['Configuration']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingsGroupResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SettingsGroup'] = IResolversParentTypes['SettingsGroup']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  range?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  titleRange?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  sections?: Resolver<Maybe<Array<Maybe<IResolversTypes['SettingsSection']>>>, ParentType, ContextType>;
  contributedByExtension?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingsSectionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SettingsSection'] = IResolversParentTypes['SettingsSection']> = {
  titleRange?: Resolver<Maybe<IResolversTypes['Range']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  settings?: Resolver<Maybe<Array<Maybe<IResolversTypes['Setting']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISettingsSubjectResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SettingsSubject'] = IResolversParentTypes['SettingsSubject']> = {
  __resolveType: TypeResolveFn<'UserSettings' | 'LocalUserSettings' | 'RemoteUserSettings' | 'FolderSettings' | 'GlobalSettings' | 'WorkspaceSettings' | 'MemorySettings' | 'DefaultSettings', ParentType, ContextType>;
};

export type IShellResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Shell'] = IResolversParentTypes['Shell']> = {
  osx?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  linux?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  windows?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IShellArgsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ShellArgs'] = IResolversParentTypes['ShellArgs']> = {
  container?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  windows?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  linux?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  osx?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISideBySideEditorResolvers = EnumResolverSignature<{ MASTER?: any, DETAILS?: any }, IResolversTypes['SideBySideEditor']>;

export type ISideBySideEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SideBySideEditorInput'] = IResolversParentTypes['SideBySideEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  master?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  details?: Resolver<Maybe<IResolversTypes['EditorInput']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISnippetResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Snippet'] = IResolversParentTypes['Snippet']> = {
  language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IStatusbarResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Statusbar'] = IResolversParentTypes['Statusbar']> = {
  items?: Resolver<Maybe<Array<Maybe<IResolversTypes['StatusbarItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IStatusbarEntryResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['StatusbarEntry'] = IResolversParentTypes['StatusbarEntry']> = {
  showTabsButtons?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showIcons?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showStatusbar?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  text?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  ariaLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  tooltip?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  color?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  backgroundColor?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  command?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  arguments?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  showBeak?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IStatusbarItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['StatusbarItem'] = IResolversParentTypes['StatusbarItem']> = {
  __resolveType: TypeResolveFn<'Terminal' | 'SelectionStatus' | 'Indentation' | 'EncodingStatus' | 'EndOfLineSequence' | 'LanguageMode' | 'SyncStatus' | 'BranchStatus', ParentType, ContextType>;
};

export type IStreamContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['StreamContent'] = IResolversParentTypes['StreamContent']> = {
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mtime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  linesRange?: Resolver<Maybe<IResolversTypes['LineRange']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ISubscriptionResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
  dummy?: SubscriptionResolver<Maybe<IResolversTypes['Int']>, "dummy", ParentType, ContextType>;
  fileData?: SubscriptionResolver<Maybe<Array<Maybe<IResolversTypes['FileChange']>>>, "fileData", ParentType, ContextType, RequireFields<ISubscriptionFileDataArgs, 'resource'>>;
  fileOperation?: SubscriptionResolver<Maybe<IResolversTypes['FileOperationOutput']>, "fileOperation", ParentType, ContextType, RequireFields<ISubscriptionFileOperationArgs, 'resource'>>;
  onDidChangeConfiguration?: SubscriptionResolver<Maybe<IResolversTypes['IConfigurationChangeEvent']>, "onDidChangeConfiguration", ParentType, ContextType>;
  onDidChangeFileSystemProviderRegistrations?: SubscriptionResolver<Maybe<IResolversTypes['IFileSystemProviderRegistrationEvent']>, "onDidChangeFileSystemProviderRegistrations", ParentType, ContextType>;
  onWillActivateFileSystemProvider?: SubscriptionResolver<Maybe<IResolversTypes['IFileSystemProviderActivationEvent']>, "onWillActivateFileSystemProvider", ParentType, ContextType>;
  readStreamTextFile?: SubscriptionResolver<Maybe<IResolversTypes['TextFileStreamContent']>, "readStreamTextFile", ParentType, ContextType, RequireFields<ISubscriptionReadStreamTextFileArgs, 'resource'>>;
  readStreamTextString?: SubscriptionResolver<Maybe<IResolversTypes['TextFilePublishContent']>, "readStreamTextString", ParentType, ContextType, RequireFields<ISubscriptionReadStreamTextStringArgs, 'resource'>>;
  searchStreamContent?: SubscriptionResolver<Maybe<IResolversTypes['SearchCompleteStream']>, "searchStreamContent", ParentType, ContextType, RequireFields<ISubscriptionSearchStreamContentArgs, never>>;
};

export type ISyncStatusResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['SyncStatus'] = IResolversParentTypes['SyncStatus']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITabCloseButtonTypeResolvers = EnumResolverSignature<{ left?: any, right?: any, off?: any }, IResolversTypes['TabCloseButtonType']>;

export type ITabSizingTypeResolvers = EnumResolverSignature<{ fit?: any, shrink?: any }, IResolversTypes['TabSizingType']>;

export type ITerminalResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['Terminal'] = IResolversParentTypes['Terminal']> = {
  alignment?: Resolver<Maybe<IResolversTypes['StatusbarAlignment']>, ParentType, ContextType>;
  container?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  entry?: Resolver<Maybe<IResolversTypes['StatusbarEntry']>, ParentType, ContextType>;
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  integrated?: Resolver<Maybe<IResolversTypes['Integrated']>, ParentType, ContextType>;
  labelContainer?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  priority?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['STATUSBAR_ITEM_ID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextBufferDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextBufferData'] = IResolversParentTypes['TextBufferData']> = {
  EOL?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  lines?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  containsRTL?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isBasicASCII?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextDocumentIdentifierResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextDocumentIdentifier'] = IResolversParentTypes['TextDocumentIdentifier']> = {
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextDocumentItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextDocumentItem'] = IResolversParentTypes['TextDocumentItem']> = {
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  languageId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  text?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextDocumentPositionParamsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextDocumentPositionParams'] = IResolversParentTypes['TextDocumentPositionParams']> = {
  __resolveType: TypeResolveFn<'ProvideTextDocumentLocationSignature', ParentType, ContextType>;
  textDocument?: Resolver<Maybe<IResolversTypes['TextDocumentIdentifier']>, ParentType, ContextType>;
  position?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
};

export type ITextDocumentRegistrationOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextDocumentRegistrationOptions'] = IResolversParentTypes['TextDocumentRegistrationOptions']> = {
  documentSelector?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextFileContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextFileContent'] = IResolversParentTypes['TextFileContent']> = {
  dirty?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  inConflictMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inErrorMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inOrphanMode?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  inPendingSave?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  preferredEncoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  preferredMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  state?: Resolver<Maybe<IResolversTypes['FileModelState']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextFilePublishContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextFilePublishContent'] = IResolversParentTypes['TextFilePublishContent']> = {
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  mtime?: Resolver<Maybe<IResolversTypes['BigInt']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  streamSeq?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['FileContentStatus']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextFileStreamContentResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextFileStreamContent'] = IResolversParentTypes['TextFileStreamContent']> = {
  resource?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  size?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  mtime?: Resolver<IResolversTypes['BigInt'], ParentType, ContextType>;
  etag?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  isReadonly?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  encoding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  value?: Resolver<Maybe<IResolversTypes['TextBufferData']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextSearchContextResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchContext'] = IResolversParentTypes['TextSearchContext']> = {
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  text?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  lineNumber?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextSearchMatchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchMatch'] = IResolversParentTypes['TextSearchMatch']> = {
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  ranges?: Resolver<Maybe<Array<Maybe<IResolversTypes['SearchRange']>>>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['TextSearchResultPreview']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextSearchPreviewOptionsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchPreviewOptions'] = IResolversParentTypes['TextSearchPreviewOptions']> = {
  matchLines?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  charsPerLine?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextSearchResultResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchResult'] = IResolversParentTypes['TextSearchResult']> = {
  __resolveType: TypeResolveFn<'TextSearchMatch' | 'TextSearchContext', ParentType, ContextType>;
};

export type ITextSearchResultPreviewResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchResultPreview'] = IResolversParentTypes['TextSearchResultPreview']> = {
  text?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  matches?: Resolver<Maybe<Array<Maybe<IResolversTypes['SearchRange']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITextSearchStatsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TextSearchStats'] = IResolversParentTypes['TextSearchStats']> = {
  type?: Resolver<Maybe<IResolversTypes['TextSearchStatsType']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IThemeLabelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ThemeLabel'] = IResolversParentTypes['ThemeLabel']> = {
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  uiTheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  path?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface ITimeScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Time'], any> {
  name: 'Time';
}

export type ITreeItemResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TreeItem'] = IResolversParentTypes['TreeItem']> = {
  handle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  parentHandle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  collapsibleState?: Resolver<Maybe<IResolversTypes['TreeItemCollapsibleState']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  icon?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  iconDark?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  themeIcon?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resourceUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  tooltip?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  contextValue?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  children?: Resolver<Maybe<Array<Maybe<IResolversTypes['TreeItem']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ITreeViewDescriptorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['TreeViewDescriptor'] = IResolversParentTypes['TreeViewDescriptor']> = {
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  order?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  weight?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  collapsed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canToggleVisibility?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hideByDefault?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IUriScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URI'], any> {
  name: 'URI';
}

export interface IUriInputScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URIInput'], any> {
  name: 'URIInput';
}

export type IUriToOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['URIToOpen'] = IResolversParentTypes['URIToOpen']> = {
  __resolveType: TypeResolveFn<'WorkspaceToOpen' | 'FolderToOpen' | 'FileToOpen', ParentType, ContextType>;
};

export type IUntitledEditorInputResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['UntitledEditorInput'] = IResolversParentTypes['UntitledEditorInput']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  resource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  typeId?: Resolver<Maybe<IResolversTypes['EDITOR_INPUT_ID']>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  fileReference?: Resolver<Maybe<IResolversTypes['FileStatWithMetadata']>, ParentType, ContextType>;
  preferredEditorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isSupportsSplitEditor?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  isPinned?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  editorId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  closable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hasAssociatedFilePath?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  shortDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mediumDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  longDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  shortTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mediumTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  longTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  suggestFileName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enconding?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IUpdateDelayedResourceResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['UpdateDelayedResource'] = IResolversParentTypes['UpdateDelayedResource']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IUpdatedResourceResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['UpdatedResource'] = IResolversParentTypes['UpdatedResource']> = {
  resource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  etag?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IUserPreferencesResResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['UserPreferencesRes'] = IResolversParentTypes['UserPreferencesRes']> = {
  prefs?: Resolver<Maybe<IResolversTypes['IUserPreferences']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IUserSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['UserSettings'] = IResolversParentTypes['UserSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface IVsBufferScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['VSBuffer'], any> {
  name: 'VSBuffer';
}

export interface IVsBufferReadableStreamScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['VSBufferReadableStream'], any> {
  name: 'VSBufferReadableStream';
}

export type IViewResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['View'] = IResolversParentTypes['View']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IViewContainerResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ViewContainer'] = IResolversParentTypes['ViewContainer']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IViewDescriptorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ViewDescriptor'] = IResolversParentTypes['ViewDescriptor']> = {
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  when?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  order?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  weight?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  collapsed?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  canToggleVisibility?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  hideByDefault?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IViewStateResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['ViewState'] = IResolversParentTypes['ViewState']> = {
  scrollTop?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  scrollTopWithoutViewZones?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  scrollLeft?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  firstPosition?: Resolver<Maybe<IResolversTypes['Position']>, ParentType, ContextType>;
  firstPositionDeltaTop?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWindowConfigurationResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WindowConfiguration'] = IResolversParentTypes['WindowConfiguration']> = {
  machineId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  windowId?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  logLevel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  mainPid?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  appRoot?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  execPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isInitialStartup?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  nodeCacheDataDir?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  backupPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  workspace?: Resolver<Maybe<IResolversTypes['WorkspaceIdentifier']>, ParentType, ContextType>;
  folderUri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  remoteAuthority?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  zoomLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  fullscreen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  maximized?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  highContrast?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  frameless?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  accessibilitySupport?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  partsSplashPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  perfStartTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  perfAppReady?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  perfWindowLoadTime?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  perfEntries?: Resolver<Maybe<IResolversTypes['AnyObject']>, ParentType, ContextType>;
  filesToOpenOrCreate?: Resolver<Maybe<Array<Maybe<IResolversTypes['Path']>>>, ParentType, ContextType>;
  filesToDiff?: Resolver<Maybe<Array<Maybe<IResolversTypes['Path']>>>, ParentType, ContextType>;
  filesToWait?: Resolver<Maybe<IResolversTypes['PathsToWaitFor']>, ParentType, ContextType>;
  termProgram?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceData'] = IResolversParentTypes['WorkspaceData']> = {
  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  folders?: Resolver<Array<Maybe<IResolversTypes['WorkspaceFolderData']>>, ParentType, ContextType>;
  configuration?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  isUntitled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceFolderDataResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceFolderData'] = IResolversParentTypes['WorkspaceFolderData']> = {
  uri?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
  index?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceIdentifierResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceIdentifier'] = IResolversParentTypes['WorkspaceIdentifier']> = {
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  configPath?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceActivityBarResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceActivityBar'] = IResolversParentTypes['WorkspacePreferenceActivityBar']> = {
  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceCommandPaletteResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceCommandPalette'] = IResolversParentTypes['WorkspacePreferenceCommandPalette']> = {
  history?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  preserveInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceEditorResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceEditor'] = IResolversParentTypes['WorkspacePreferenceEditor']> = {
  centeredLayoutAutoResize?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  closeEmptyGroups?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  closeOnFileDelete?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enablePreview?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  enablePreviewFromQuickOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  focusRecentEditorAfterClose?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  highlightModifiedTabs?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  labelFormat?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  openPositioning?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  openSideBySideDirection?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  restoreViewState?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  revealIfOpen?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showIcons?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  showTabs?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  splitSizing?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  tabCloseButton?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  tabSizing?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceExperimentalResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceExperimental'] = IResolversParentTypes['WorkspacePreferenceExperimental']> = {
  editorAssociations?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceListResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceList'] = IResolversParentTypes['WorkspacePreferenceList']> = {
  automaticKeyboardNavigation?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  horizontalScrolling?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  keyboardNavigation?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  multiSelectModifier?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  openMode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferencePanelResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferencePanel'] = IResolversParentTypes['WorkspacePreferencePanel']> = {
  defaultLocation?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceQuickOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceQuickOpen'] = IResolversParentTypes['WorkspacePreferenceQuickOpen']> = {
  closeOnFocusLost?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  preserveInput?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceSettings'] = IResolversParentTypes['WorkspacePreferenceSettings']> = {
  editor?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enableNaturalLanguageSearch?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  openDefaultKeybindings?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  settingsSearchTocBehavior?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  useSplitJSON?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceSideBarResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceSideBar'] = IResolversParentTypes['WorkspacePreferenceSideBar']> = {
  location?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceStatusBarResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceStatusBar'] = IResolversParentTypes['WorkspacePreferenceStatusBar']> = {
  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceTipsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceTips'] = IResolversParentTypes['WorkspacePreferenceTips']> = {
  enabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  horizontalScrolling?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  indent?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  renderIndentGuides?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceViewResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceView'] = IResolversParentTypes['WorkspacePreferenceView']> = {
  alwaysShowHeaderActions?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspacePreferenceWorkbenchResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspacePreferenceWorkbench'] = IResolversParentTypes['WorkspacePreferenceWorkbench']> = {
  colorTheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  enableExperiments?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fontAliasing?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  iconTheme?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  startupEditor?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  view?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceView']>, ParentType, ContextType>;
  tips?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceTips']>, ParentType, ContextType>;
  statusBar?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceStatusBar']>, ParentType, ContextType>;
  sideBar?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceSideBar']>, ParentType, ContextType>;
  settings?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceSettings']>, ParentType, ContextType>;
  quickOpen?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceQuickOpen']>, ParentType, ContextType>;
  panel?: Resolver<Maybe<IResolversTypes['WorkspacePreferencePanel']>, ParentType, ContextType>;
  list?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceList']>, ParentType, ContextType>;
  experimental?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceExperimental']>, ParentType, ContextType>;
  editor?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceEditor']>, ParentType, ContextType>;
  commandPalette?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceCommandPalette']>, ParentType, ContextType>;
  activityBar?: Resolver<Maybe<IResolversTypes['WorkspacePreferenceActivityBar']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceResResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceRes'] = IResolversParentTypes['WorkspaceRes']> = {
  uri?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceSettingsResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceSettings'] = IResolversParentTypes['WorkspaceSettings']> = {
  id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
  latestSettings?: Resolver<Maybe<IResolversTypes['Settings']>, ParentType, ContextType>;
  settingsURL?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  viewerCanAdminister?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
  settingsCascade?: Resolver<IResolversTypes['SettingsCascade'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IWorkspaceToOpenResolvers<ContextType = ApolloContext, ParentType extends IResolversParentTypes['WorkspaceToOpen'] = IResolversParentTypes['WorkspaceToOpen']> = {
  workspaceUri?: Resolver<IResolversTypes['URI'], ParentType, ContextType>;
  label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IResolvers<ContextType = ApolloContext> = {
  Action?: IActionResolvers<ContextType>;
  ActionItem?: IActionItemResolvers<ContextType>;
  ActionRun?: IActionRunResolvers<ContextType>;
  Actions?: IActionsResolvers<ContextType>;
  AddFoldersRequest?: IAddFoldersRequestResolvers<ContextType>;
  AdminIdeSettings?: IAdminIdeSettingsResolvers<ContextType>;
  Anchor?: IAnchorResolvers<ContextType>;
  AnyObject?: GraphQLScalarType;
  ArgsType?: IArgsTypeResolvers<ContextType>;
  Assets?: IAssetsResolvers<ContextType>;
  Author?: IAuthorResolvers<ContextType>;
  BaseExtension?: IBaseExtensionResolvers<ContextType>;
  BigInt?: GraphQLScalarType;
  BranchStatus?: IBranchStatusResolvers<ContextType>;
  Bundles?: IBundlesResolvers<ContextType>;
  CachedSearchStats?: ICachedSearchStatsResolvers<ContextType>;
  ChangeRange?: IChangeRangeResolvers<ContextType>;
  ChangesChunk?: IChangesChunkResolvers<ContextType>;
  CheckboxOptions?: ICheckboxOptionsResolvers<ContextType>;
  CloseDirection?: ICloseDirectionResolvers;
  CloseEditorsFilter?: ICloseEditorsFilterResolvers<ContextType>;
  CodeEditorViewState?: ICodeEditorViewStateResolvers<ContextType>;
  CommandHandlerDescriptionType?: ICommandHandlerDescriptionTypeResolvers<ContextType>;
  CommandType?: ICommandTypeResolvers<ContextType>;
  CommandsType?: ICommandsTypeResolvers<ContextType>;
  Configuration?: IConfigurationResolvers<ContextType>;
  ConfigurationData?: IConfigurationDataResolvers<ContextType>;
  ConfigurationExtensionInfo?: IConfigurationExtensionInfoResolvers<ContextType>;
  ConfigurationModel?: IConfigurationModelResolvers<ContextType>;
  ConfigurationOverrides?: IConfigurationOverridesResolvers<ContextType>;
  ConfigurationScope?: IConfigurationScopeResolvers;
  ConfigurationTarget?: IConfigurationTargetResolvers;
  ContentChangedEvent?: IContentChangedEventResolvers<ContextType>;
  Context?: IContextResolvers<ContextType>;
  ContextMenu?: IContextMenuResolvers<ContextType>;
  Contributes?: IContributesResolvers<ContextType>;
  CrashReporterStartOptions?: ICrashReporterStartOptionsResolvers<ContextType>;
  CursorState?: ICursorStateResolvers<ContextType>;
  DataUriEditorInput?: IDataUriEditorInputResolvers<ContextType>;
  Date?: GraphQLScalarType;
  DateTime?: GraphQLScalarType;
  Debugger?: IDebuggerResolvers<ContextType>;
  DefaultPreferencesResponse?: IDefaultPreferencesResponseResolvers<ContextType>;
  DefaultSettings?: IDefaultSettingsResolvers<ContextType>;
  Detail?: IDetailResolvers<ContextType>;
  DevToolsOptions?: IDevToolsOptionsResolvers<ContextType>;
  Dialog?: IDialogResolvers<ContextType>;
  DialogResult?: IDialogResultResolvers<ContextType>;
  DiffEditorInput?: IDiffEditorInputResolvers<ContextType>;
  DocSitePage?: IDocSitePageResolvers<ContextType>;
  DockLayout?: IDockLayoutResolvers<ContextType>;
  DocumentFilter?: IDocumentFilterResolvers<ContextType>;
  EditKeybindingItem?: IEditKeybindingItemResolvers<ContextType>;
  EditorChildren?: IEditorChildrenResolvers<ContextType>;
  EditorGroup?: IEditorGroupResolvers<ContextType>;
  EditorGroupLayout?: IEditorGroupLayoutResolvers<ContextType>;
  EditorIdentifier?: IEditorIdentifierResolvers<ContextType>;
  EditorInput?: IEditorInputResolvers<ContextType>;
  EditorOpenPositioning?: IEditorOpenPositioningResolvers;
  EditorPart?: IEditorPartResolvers<ContextType>;
  EditorPartOptions_Input?: IEditorPartOptions_InputResolvers<ContextType>;
  EditorSettings?: IEditorSettingsResolvers<ContextType>;
  EditorsOrder?: IEditorsOrderResolvers;
  EmptyResponse?: IEmptyResponseResolvers<ContextType>;
  EncodingStatus?: IEncodingStatusResolvers<ContextType>;
  EndOfLineSequence?: IEndOfLineSequenceResolvers<ContextType>;
  Engines?: IEnginesResolvers<ContextType>;
  EnterWorkspaceResult?: IEnterWorkspaceResultResolvers<ContextType>;
  Environment?: IEnvironmentResolvers<ContextType>;
  ExtensionColor?: IExtensionColorResolvers<ContextType>;
  ExtensionColorTypes?: IExtensionColorTypesResolvers<ContextType>;
  ExtensionConfiguration?: IExtensionConfigurationResolvers<ContextType>;
  ExtensionConfigurationProperty?: IExtensionConfigurationPropertyResolvers<ContextType>;
  ExtensionContributions?: IExtensionContributionsResolvers<ContextType>;
  ExtensionHostDebugParams?: IExtensionHostDebugParamsResolvers<ContextType>;
  ExtensionIdentifier?: IExtensionIdentifierResolvers<ContextType>;
  ExtensionInstance?: IExtensionInstanceResolvers<ContextType>;
  ExtensionJSONValidation?: IExtensionJsonValidationResolvers<ContextType>;
  ExtensionLanguage?: IExtensionLanguageResolvers<ContextType>;
  ExtensionManifest?: IExtensionManifestResolvers<ContextType>;
  ExtensionManifestBugs?: IExtensionManifestBugsResolvers<ContextType>;
  ExtensionManifestRepository?: IExtensionManifestRepositoryResolvers<ContextType>;
  ExtensionPackageType?: IExtensionPackageTypeResolvers<ContextType>;
  ExtensionRegistry?: IExtensionRegistryResolvers<ContextType>;
  ExtensionRegistryCreateExtensionResult?: IExtensionRegistryCreateExtensionResultResolvers<ContextType>;
  ExtensionRegistryPublishExtensionResult?: IExtensionRegistryPublishExtensionResultResolvers<ContextType>;
  ExtensionRegistryUpdateExtensionResult?: IExtensionRegistryUpdateExtensionResultResolvers<ContextType>;
  ExtensionRelease?: IExtensionReleaseResolvers<ContextType>;
  FieldError?: IFieldErrorResolvers<ContextType>;
  FileChange?: IFileChangeResolvers<ContextType>;
  FileContent?: IFileContentResolvers<ContextType>;
  FileDeleteOptions?: IFileDeleteOptionsResolvers<ContextType>;
  FileEditorInput?: IFileEditorInputResolvers<ContextType>;
  FileFilter?: IFileFilterResolvers<ContextType>;
  FileIndexProviderStats?: IFileIndexProviderStatsResolvers<ContextType>;
  FileMatch?: IFileMatchResolvers<ContextType>;
  FileOpenOptions?: IFileOpenOptionsResolvers<ContextType>;
  FileOperationOutput?: IFileOperationOutputResolvers<ContextType>;
  FileOverwriteOptions?: IFileOverwriteOptionsResolvers<ContextType>;
  FileResult?: IFileResultResolvers<ContextType>;
  FileSearchProviderStats?: IFileSearchProviderStatsResolvers<ContextType>;
  FileSearchStats?: IFileSearchStatsResolvers<ContextType>;
  FileSearchStatsdetailStats?: IFileSearchStatsdetailStatsResolvers<ContextType>;
  FileStat?: IFileStatResolvers<ContextType>;
  FileStatWithMetadata?: IFileStatWithMetadataResolvers<ContextType>;
  FileStreamContent?: IFileStreamContentResolvers<ContextType>;
  FileToOpen?: IFileToOpenResolvers<ContextType>;
  FileWriteOptions?: IFileWriteOptionsResolvers<ContextType>;
  Files?: IFilesResolvers<ContextType>;
  Files_Stat?: IFiles_StatResolvers<ContextType>;
  FolderConfigurationModel?: IFolderConfigurationModelResolvers<ContextType>;
  FolderQuery?: IFolderQueryResolvers<ContextType>;
  FolderSettings?: IFolderSettingsResolvers<ContextType>;
  FolderToOpen?: IFolderToOpenResolvers<ContextType>;
  GalleryBanner?: IGalleryBannerResolvers<ContextType>;
  GalleryExtension?: IGalleryExtensionResolvers<ContextType>;
  GalleryExtensionAsset?: IGalleryExtensionAssetResolvers<ContextType>;
  GalleryExtensionAssets?: IGalleryExtensionAssetsResolvers<ContextType>;
  GalleryExtensionProperties?: IGalleryExtensionPropertiesResolvers<ContextType>;
  GalleryExtensionResources?: IGalleryExtensionResourcesResolvers<ContextType>;
  GalleryPager?: IGalleryPagerResolvers<ContextType>;
  GeoLocation?: IGeoLocationResolvers<ContextType>;
  Git?: IGitResolvers<ContextType>;
  GitDecorations?: IGitDecorationsResolvers<ContextType>;
  GlobalSettings?: IGlobalSettingsResolvers<ContextType>;
  GoToLineQuickAccess?: IGoToLineQuickAccessResolvers<ContextType>;
  Grammar?: IGrammarResolvers<ContextType>;
  GroupDirection?: IGroupDirectionResolvers;
  GroupLayoutArgument?: IGroupLayoutArgumentResolvers<ContextType>;
  GroupLocation?: IGroupLocationResolvers;
  GroupOrientation?: IGroupOrientationResolvers;
  GroupsArrangement?: IGroupsArrangementResolvers;
  GroupsOrder?: IGroupsOrderResolvers;
  Hover?: IHoverResolvers<ContextType>;
  IBaseStat?: IIBaseStatResolvers<ContextType>;
  IBaseStatWithMetadata?: IIBaseStatWithMetadataResolvers<ContextType>;
  IBaseTextFileContent?: IIBaseTextFileContentResolvers<ContextType>;
  IBehaviorSubject?: IIBehaviorSubjectResolvers<ContextType>;
  IBehaviorSubjectValue?: IIBehaviorSubjectValueResolvers<ContextType>;
  ICommonQueryProps?: IICommonQueryPropsResolvers<ContextType>;
  IConfigurationChangeEvent?: IIConfigurationChangeEventResolvers<ContextType>;
  IConfigurationService?: IIConfigurationServiceResolvers<ContextType>;
  IContentChangedEvent?: IIContentChangedEventResolvers<ContextType>;
  IDebugParams?: IIDebugParamsResolvers<ContextType>;
  IDestinationAnonymousSubject?: IIDestinationAnonymousSubjectResolvers<ContextType>;
  IDocumentSelector?: IIDocumentSelectorResolvers<ContextType>;
  IEditorGroup?: IIEditorGroupResolvers<ContextType>;
  IEditorInput?: IIEditorInputResolvers<ContextType>;
  IEditorInputWithGroupFields?: IIEditorInputWithGroupFieldsResolvers<ContextType>;
  IEncodingSupport?: IIEncodingSupportResolvers<ContextType>;
  IFileClientMetadata?: IIFileClientMetadataResolvers<ContextType>;
  IFileEditorInput?: IIFileEditorInputResolvers<ContextType>;
  IFileMatch?: IIFileMatchResolvers<ContextType>;
  IFileSystemProviderActivationEvent?: IIFileSystemProviderActivationEventResolvers<ContextType>;
  IFileSystemProviderRegistrationEvent?: IIFileSystemProviderRegistrationEventResolvers<ContextType>;
  IModeSupport?: IIModeSupportResolvers<ContextType>;
  IModel?: IIModelResolvers<ContextType>;
  IObservableResult?: IIObservableResultResolvers<ContextType>;
  IPathData?: IIPathDataResolvers<ContextType>;
  IPathsToWaitForData?: IIPathsToWaitForDataResolvers<ContextType>;
  IResourceUtilizationSettings?: IIResourceUtilizationSettingsResolvers<ContextType>;
  ISearchCompleteStats?: IISearchCompleteStatsResolvers<ContextType>;
  ISearchProgress?: IISearchProgressResolvers<ContextType>;
  ISettingsSubject?: IISettingsSubjectResolvers<ContextType>;
  ISideBySideEditorInput?: IISideBySideEditorInputResolvers<ContextType>;
  ISourceAnonymousSubject?: IISourceAnonymousSubjectResolvers<ContextType>;
  IStaticWorkspaceData?: IIStaticWorkspaceDataResolvers<ContextType>;
  IStatusbarItem?: IIStatusbarItemResolvers<ContextType>;
  ISwitchMapOperator?: IISwitchMapOperatorResolvers<ContextType>;
  ITextDocumentIdentifier?: IITextDocumentIdentifierResolvers<ContextType>;
  ITreeItem?: IITreeItemResolvers<ContextType>;
  IUntitledFileValue?: IIUntitledFileValueResolvers<ContextType>;
  IUserPreferences?: IIUserPreferencesResolvers<ContextType>;
  IUserSettings?: IIUserSettingsResolvers<ContextType>;
  IViewComponentData?: IIViewComponentDataResolvers<ContextType>;
  IViewDescriptor?: IIViewDescriptorResolvers<ContextType>;
  IWorkspaceRoot?: IIWorkspaceRootResolvers<ContextType>;
  ImportResult?: IImportResultResolvers<ContextType>;
  Indentation?: IIndentationResolvers<ContextType>;
  InputTypeDetail?: IInputTypeDetailResolvers<ContextType>;
  InstalledExtension?: IInstalledExtensionResolvers<ContextType>;
  Integrated?: IIntegratedResolvers<ContextType>;
  JSON?: GraphQLScalarType;
  JSONObject?: GraphQLScalarType;
  KeyBinding?: IKeyBindingResolvers<ContextType>;
  KeybindingContextMenu?: IKeybindingContextMenuResolvers<ContextType>;
  KeybindingEditorInput?: IKeybindingEditorInputResolvers<ContextType>;
  KeybindingItem?: IKeybindingItemResolvers<ContextType>;
  Keybindings?: IKeybindingsResolvers<ContextType>;
  KeyboardEvent_output?: IKeyboardEvent_OutputResolvers<ContextType>;
  LableFormatType?: ILableFormatTypeResolvers;
  LanguageMode?: ILanguageModeResolvers<ContextType>;
  Languages?: ILanguagesResolvers<ContextType>;
  LineMatch?: ILineMatchResolvers<ContextType>;
  LineRange?: ILineRangeResolvers<ContextType>;
  LocalUserSettings?: ILocalUserSettingsResolvers<ContextType>;
  Localization?: ILocalizationResolvers<ContextType>;
  LocalizationTranslation?: ILocalizationTranslationResolvers<ContextType>;
  Location?: ILocationResolvers<ContextType>;
  MarkupContent?: IMarkupContentResolvers<ContextType>;
  Match?: IMatchResolvers<ContextType>;
  MemorySettings?: IMemorySettingsResolvers<ContextType>;
  MenuItem?: IMenuItemResolvers<ContextType>;
  MenuItemAction?: IMenuItemActionResolvers<ContextType>;
  MenuItemActionContext?: IMenuItemActionContextResolvers<ContextType>;
  MenuItemActionDebug?: IMenuItemActionDebugResolvers<ContextType>;
  MenuItemActionEditor?: IMenuItemActionEditorResolvers<ContextType>;
  MenuItemActionEditorTitle?: IMenuItemActionEditorTitleResolvers<ContextType>;
  MenuItemActionScm?: IMenuItemActionScmResolvers<ContextType>;
  MenuItemActionScmChange?: IMenuItemActionScmChangeResolvers<ContextType>;
  MenuItemActionView?: IMenuItemActionViewResolvers<ContextType>;
  Menus?: IMenusResolvers<ContextType>;
  MergeGroupMode?: IMergeGroupModeResolvers;
  MessageBoxOptions?: IMessageBoxOptionsResolvers<ContextType>;
  MessageBoxResult?: IMessageBoxResultResolvers<ContextType>;
  MessageLink?: IMessageLinkResolvers<ContextType>;
  Mutation?: IMutationResolvers<ContextType>;
  NativeOpenDialogOptions?: INativeOpenDialogOptionsResolvers<ContextType>;
  NewWindowOptions?: INewWindowOptionsResolvers<ContextType>;
  Node?: INodeResolvers<ContextType>;
  Notification?: INotificationResolvers<ContextType>;
  NotificationActions?: INotificationActionsResolvers<ContextType>;
  NotificationChangeEvent?: INotificationChangeEventResolvers<ContextType>;
  NotificationMessage?: INotificationMessageResolvers<ContextType>;
  NotificationSeverity?: INotificationSeverityResolvers;
  NotificationViewItem?: INotificationViewItemResolvers<ContextType>;
  NotificationViewItemProgress?: INotificationViewItemProgressResolvers<ContextType>;
  NotificationViewItemProgressState?: INotificationViewItemProgressStateResolvers<ContextType>;
  Notifications?: INotificationsResolvers<ContextType>;
  Observable?: GraphQLScalarType;
  OneSearchPathPattern?: IOneSearchPathPatternResolvers<ContextType>;
  OpenConfiguration?: IOpenConfigurationResolvers<ContextType>;
  OpenDialogOptions?: IOpenDialogOptionsResolvers<ContextType>;
  OpenFileRequest?: IOpenFileRequestResolvers<ContextType>;
  OpenPositioningType?: IOpenPositioningTypeResolvers;
  OpenSettings?: IOpenSettingsResolvers<ContextType>;
  OpenSideBySideDirection?: IOpenSideBySideDirectionResolvers;
  Output?: IOutputResolvers<ContextType>;
  Overrides?: IOverridesResolvers<ContextType>;
  PageInfo?: IPageInfoResolvers<ContextType>;
  Path?: IPathResolvers<ContextType>;
  PathsToWaitFor?: IPathsToWaitForResolvers<ContextType>;
  PatternInfo?: IPatternInfoResolvers<ContextType>;
  PendingStatusbarEntry?: IPendingStatusbarEntryResolvers<ContextType>;
  Position?: IPositionResolvers<ContextType>;
  PreferenceItem?: IPreferenceItemResolvers<ContextType>;
  PreferencesEditorInput?: IPreferencesEditorInputResolvers<ContextType>;
  PreferencesType?: IPreferencesTypeResolvers<ContextType>;
  PrimaryButtonAction?: IPrimaryButtonActionResolvers<ContextType>;
  ProcessMonitoring?: IProcessMonitoringResolvers<ContextType>;
  Progress?: IProgressResolvers<ContextType>;
  ProvideTextDocumentLocationSignature?: IProvideTextDocumentLocationSignatureResolvers<ContextType>;
  Query?: IQueryResolvers<ContextType>;
  QuickInput?: IQuickInputResolvers<ContextType>;
  QuickInputModel?: IQuickInputModelResolvers<ContextType>;
  QuickPick?: IQuickPickResolvers<ContextType>;
  QuickPickItem?: IQuickPickItemResolvers<ContextType>;
  QuickPickItemHighlights?: IQuickPickItemHighlightsResolvers<ContextType>;
  Range?: IRangeResolvers<ContextType>;
  RegistryEntry?: IRegistryEntryResolvers<ContextType>;
  RegistryExtension?: IRegistryExtensionResolvers<ContextType>;
  RegistryExtensionConnection?: IRegistryExtensionConnectionResolvers<ContextType>;
  RegistryPublisher?: IRegistryPublisherResolvers<ContextType>;
  RegistryPublisherConnection?: IRegistryPublisherConnectionResolvers<ContextType>;
  RemoteUserSettings?: IRemoteUserSettingsResolvers<ContextType>;
  ReplaceContentResult?: IReplaceContentResultResolvers<ContextType>;
  ResolveFileResult?: IResolveFileResultResolvers<ContextType>;
  ResolveFileResultWithMetadata?: IResolveFileResultWithMetadataResolvers<ContextType>;
  ResourceEditorInput?: IResourceEditorInputResolvers<ContextType>;
  ResourceEncoding?: IResourceEncodingResolvers<ContextType>;
  ResourceMapConfigurationModel?: IResourceMapConfigurationModelResolvers<ContextType>;
  RevealOptions?: IRevealOptionsResolvers<ContextType>;
  RunActionInWindowRequest?: IRunActionInWindowRequestResolvers<ContextType>;
  RunKeybindingInWindowRequest?: IRunKeybindingInWindowRequestResolvers<ContextType>;
  SaveDialogOptions?: ISaveDialogOptionsResolvers<ContextType>;
  SaveWorkspaceRes?: ISaveWorkspaceResResolvers<ContextType>;
  Scripts?: IScriptsResolvers<ContextType>;
  Search?: ISearchResolvers<ContextType>;
  SearchComplete?: ISearchCompleteResolvers<ContextType>;
  SearchCompleteStatsStats?: ISearchCompleteStatsStatsResolvers<ContextType>;
  SearchCompleteStream?: ISearchCompleteStreamResolvers<ContextType>;
  SearchEngineStats?: ISearchEngineStatsResolvers<ContextType>;
  SearchLog?: ISearchLogResolvers<ContextType>;
  SearchPathPattern?: ISearchPathPatternResolvers<ContextType>;
  SearchProgressItem?: ISearchProgressItemResolvers<ContextType>;
  SearchQuickOpen?: ISearchQuickOpenResolvers<ContextType>;
  SearchRange?: ISearchRangeResolvers<ContextType>;
  SelectedOutput?: ISelectedOutputResolvers<ContextType>;
  SelectionStatus?: ISelectionStatusResolvers<ContextType>;
  Setting?: ISettingResolvers<ContextType>;
  Settings?: ISettingsResolvers<ContextType>;
  SettingsCascade?: ISettingsCascadeResolvers<ContextType>;
  SettingsGroup?: ISettingsGroupResolvers<ContextType>;
  SettingsSection?: ISettingsSectionResolvers<ContextType>;
  SettingsSubject?: ISettingsSubjectResolvers<ContextType>;
  Shell?: IShellResolvers<ContextType>;
  ShellArgs?: IShellArgsResolvers<ContextType>;
  SideBySideEditor?: ISideBySideEditorResolvers;
  SideBySideEditorInput?: ISideBySideEditorInputResolvers<ContextType>;
  Snippet?: ISnippetResolvers<ContextType>;
  Statusbar?: IStatusbarResolvers<ContextType>;
  StatusbarEntry?: IStatusbarEntryResolvers<ContextType>;
  StatusbarItem?: IStatusbarItemResolvers<ContextType>;
  StreamContent?: IStreamContentResolvers<ContextType>;
  Subscription?: ISubscriptionResolvers<ContextType>;
  SyncStatus?: ISyncStatusResolvers<ContextType>;
  TabCloseButtonType?: ITabCloseButtonTypeResolvers;
  TabSizingType?: ITabSizingTypeResolvers;
  Terminal?: ITerminalResolvers<ContextType>;
  TextBufferData?: ITextBufferDataResolvers<ContextType>;
  TextDocumentIdentifier?: ITextDocumentIdentifierResolvers<ContextType>;
  TextDocumentItem?: ITextDocumentItemResolvers<ContextType>;
  TextDocumentPositionParams?: ITextDocumentPositionParamsResolvers<ContextType>;
  TextDocumentRegistrationOptions?: ITextDocumentRegistrationOptionsResolvers<ContextType>;
  TextFileContent?: ITextFileContentResolvers<ContextType>;
  TextFilePublishContent?: ITextFilePublishContentResolvers<ContextType>;
  TextFileStreamContent?: ITextFileStreamContentResolvers<ContextType>;
  TextSearchContext?: ITextSearchContextResolvers<ContextType>;
  TextSearchMatch?: ITextSearchMatchResolvers<ContextType>;
  TextSearchPreviewOptions?: ITextSearchPreviewOptionsResolvers<ContextType>;
  TextSearchResult?: ITextSearchResultResolvers<ContextType>;
  TextSearchResultPreview?: ITextSearchResultPreviewResolvers<ContextType>;
  TextSearchStats?: ITextSearchStatsResolvers<ContextType>;
  ThemeLabel?: IThemeLabelResolvers<ContextType>;
  Time?: GraphQLScalarType;
  TreeItem?: ITreeItemResolvers<ContextType>;
  TreeViewDescriptor?: ITreeViewDescriptorResolvers<ContextType>;
  URI?: GraphQLScalarType;
  URIInput?: GraphQLScalarType;
  URIToOpen?: IUriToOpenResolvers<ContextType>;
  UntitledEditorInput?: IUntitledEditorInputResolvers<ContextType>;
  UpdateDelayedResource?: IUpdateDelayedResourceResolvers<ContextType>;
  UpdatedResource?: IUpdatedResourceResolvers<ContextType>;
  UserPreferencesRes?: IUserPreferencesResResolvers<ContextType>;
  UserSettings?: IUserSettingsResolvers<ContextType>;
  VSBuffer?: GraphQLScalarType;
  VSBufferReadableStream?: GraphQLScalarType;
  View?: IViewResolvers<ContextType>;
  ViewContainer?: IViewContainerResolvers<ContextType>;
  ViewDescriptor?: IViewDescriptorResolvers<ContextType>;
  ViewState?: IViewStateResolvers<ContextType>;
  WindowConfiguration?: IWindowConfigurationResolvers<ContextType>;
  WorkspaceData?: IWorkspaceDataResolvers<ContextType>;
  WorkspaceFolderData?: IWorkspaceFolderDataResolvers<ContextType>;
  WorkspaceIdentifier?: IWorkspaceIdentifierResolvers<ContextType>;
  WorkspacePreferenceActivityBar?: IWorkspacePreferenceActivityBarResolvers<ContextType>;
  WorkspacePreferenceCommandPalette?: IWorkspacePreferenceCommandPaletteResolvers<ContextType>;
  WorkspacePreferenceEditor?: IWorkspacePreferenceEditorResolvers<ContextType>;
  WorkspacePreferenceExperimental?: IWorkspacePreferenceExperimentalResolvers<ContextType>;
  WorkspacePreferenceList?: IWorkspacePreferenceListResolvers<ContextType>;
  WorkspacePreferencePanel?: IWorkspacePreferencePanelResolvers<ContextType>;
  WorkspacePreferenceQuickOpen?: IWorkspacePreferenceQuickOpenResolvers<ContextType>;
  WorkspacePreferenceSettings?: IWorkspacePreferenceSettingsResolvers<ContextType>;
  WorkspacePreferenceSideBar?: IWorkspacePreferenceSideBarResolvers<ContextType>;
  WorkspacePreferenceStatusBar?: IWorkspacePreferenceStatusBarResolvers<ContextType>;
  WorkspacePreferenceTips?: IWorkspacePreferenceTipsResolvers<ContextType>;
  WorkspacePreferenceView?: IWorkspacePreferenceViewResolvers<ContextType>;
  WorkspacePreferenceWorkbench?: IWorkspacePreferenceWorkbenchResolvers<ContextType>;
  WorkspaceRes?: IWorkspaceResResolvers<ContextType>;
  WorkspaceSettings?: IWorkspaceSettingsResolvers<ContextType>;
  WorkspaceToOpen?: IWorkspaceToOpenResolvers<ContextType>;
};


export type IDirectiveResolvers<ContextType = ApolloContext> = {
  cacheControl?: ICacheControlDirectiveResolver<any, any, ContextType>;
};


export const DefaultSettingFragmentDoc = gql`
    fragment DefaultSetting on Setting {
  key
  value
  description
  descriptionIsMarkdown
  deprecationMessage
  type
  enum
  enumDescriptions
  enumDescriptionsAreMarkdown
  tags
}
    `;
export const SettingRangeFragmentDoc = gql`
    fragment SettingRange on Range {
  start {
    line
    lineNumber
    column
    character
  }
  end {
    line
    lineNumber
    column
    character
  }
  startLineNumber
  startColumn
  endLineNumber
  endColumn
}
    `;
export const TerminalConfigurationFragmentDoc = gql`
    fragment TerminalConfiguration on Terminal {
  integrated {
    setLocaleVariables
    shell {
      osx
      linux
      windows
      container
    }
    shellArgs {
      container
      windows
      osx
      linux
    }
  }
}
    `;
export const SearchConfigurationFragmentDoc = gql`
    fragment SearchConfiguration on Search {
  location
  smartCase
  useRipgrep
  useIgnoreFiles
  followSymlinks
  globalFindClipboard
  quickOpen {
    includeSymbols
  }
  exclude
}
    `;
export const LanguagesConfigurationFragmentDoc = gql`
    fragment LanguagesConfiguration on Languages {
  go
  css
  html
  json
  yaml
  typescript
  javascript
}
    `;
export const FilesConfigurationFragmentDoc = gql`
    fragment FilesConfiguration on Files {
  eol
  hotExit
  encoding
  autoSave
  autoSaveDelay
  defaultLanguage
  autoGuessEncoding
  insertFinalNewline
  trimTrailingWhitespace
  useExperimentalFileWatcher
  watcherExclude
  exclude
}
    `;
export const GitConfigurationFragmentDoc = gql`
    fragment GitConfiguration on Git {
  path
  enabled
  autofetch
  countBadge
  autorefresh
  confirmSync
  checkoutType
  inputValidation
  detectSubmodules
  enableSmartCommit
  ignoreLimitWarning
  ignoreLegacyWarning
  enableCommitSigning
  defaultCloneDirectory
  autoRepositoryDetection
  ignoreMissingGitWarning
  showInlineOpenFileAction
  promptToSaveFilesBeforeCommit
  decorations {
    enabled
  }
}
    `;
export const WorkspaceConfigurationFragmentDoc = gql`
    fragment WorkspaceConfiguration on WorkspacePreferenceWorkbench {
  colorTheme
  enableExperiments
  fontAliasing
  iconTheme
  startupEditor
  view {
    alwaysShowHeaderActions
  }
  tips {
    enabled
    horizontalScrolling
    indent
    renderIndentGuides
  }
  statusBar {
    visible
  }
  settings {
    editor
    enableNaturalLanguageSearch
    openDefaultKeybindings
    settingsSearchTocBehavior
    useSplitJSON
  }
  quickOpen {
    closeOnFocusLost
    preserveInput
  }
  panel {
    defaultLocation
  }
  list {
    automaticKeyboardNavigation
    horizontalScrolling
    keyboardNavigation
    multiSelectModifier
    openMode
  }
  experimental {
    editorAssociations
  }
  editor {
    centeredLayoutAutoResize
    closeEmptyGroups
    closeOnFileDelete
    enablePreview
    enablePreviewFromQuickOpen
    focusRecentEditorAfterClose
    highlightModifiedTabs
    labelFormat
    openPositioning
    openSideBySideDirection
    restoreViewState
    revealIfOpen
    showIcons
    showTabs
    splitSizing
    tabCloseButton
    tabSizing
  }
  commandPalette {
    history
    preserveInput
  }
  activityBar {
    visible
  }
}
    `;
export const ViewerSettingsFragmentDoc = gql`
    fragment ViewerSettings on SettingsCascade {
  final
  subjects {
    ... on UserSettings {
      id
      settingsURL
      latestSettings {
        contents
        createdAt
      }
      settingsCascade {
        finalConfiguration {
          terminal {
            ...TerminalConfiguration
          }
          search {
            ...SearchConfiguration
          }
          languages {
            ...LanguagesConfiguration
          }
          output {
            maxChannelHistory
          }
          files {
            ...FilesConfiguration
          }
          git {
            ...GitConfiguration
          }
          workspace {
            ...WorkspaceConfiguration
          }
        }
      }
    }
    ... on FolderSettings {
      id
      settingsURL
      latestSettings {
        contents
        createdAt
      }
      settingsCascade {
        finalConfiguration {
          terminal {
            ...TerminalConfiguration
          }
          search {
            ...SearchConfiguration
          }
          languages {
            ...LanguagesConfiguration
          }
          output {
            maxChannelHistory
          }
          files {
            ...FilesConfiguration
          }
          git {
            ...GitConfiguration
          }
          workspace {
            ...WorkspaceConfiguration
          }
        }
      }
    }
    ... on GlobalSettings {
      id
      settingsURL
      latestSettings {
        contents
        createdAt
      }
      settingsCascade {
        finalConfiguration {
          terminal {
            ...TerminalConfiguration
          }
          search {
            ...SearchConfiguration
          }
          languages {
            ...LanguagesConfiguration
          }
          output {
            maxChannelHistory
          }
          files {
            ...FilesConfiguration
          }
          git {
            ...GitConfiguration
          }
          workspace {
            ...WorkspaceConfiguration
          }
        }
      }
    }
  }
}
    ${TerminalConfigurationFragmentDoc}
${SearchConfigurationFragmentDoc}
${LanguagesConfigurationFragmentDoc}
${FilesConfigurationFragmentDoc}
${GitConfigurationFragmentDoc}
${WorkspaceConfigurationFragmentDoc}`;
export const AllContextFragmentDoc = gql`
    fragment AllContext on Context {
  originalResourceScheme
  view
  viewItem
  gitOpenRepositoryCount
  isInDiffEditor
  isInDiffRightEditor
  resourceScheme
  resourceFilename
  resourceLangId
  resource
  resourceExtName
  resourceSet
  isFileSystemResource
  inputFocus
  suggestWidgetVisible
  suggestWidgetMultipleSuggestions
  suggestionMakesTextEdit
  acceptSuggestionOnEnter
  hasOtherSuggestions
  groupFocusedInOpenEditors
  dirtyEditor
  resourceSelectedForCompare
  fileCopied
  breadcrumbsPossible
  breadcrumbsVisible
  breadcrumbsActive
  canNavigateBack
  canNavigateForward
  canNavigateToLastEditLocation
  dirtyDiffVisible
  cancellableOperation
  parameterHintsVisible
  parameterHintsMultipleSignatures
  markdownPreviewFocus
  isMac
  isLinux
  isWindows
  remoteAuthority
  remoteConnectionState
  hasMacNativeTabs
  supportsWorkspaces
  isDevelopment
  workbenchState
  workspaceFolderCount
  remoteFileDialogVisible
  isFullscreen
  atEndOfWord
  scmRepository
  scmProvider
  scmResourceGroup
  inDiffEditorKey
  isDominatedByLongLines
  isWordWrapMinified
  commentThread
  commentThreadisEmpty
  commentIsEmpty
  commentEditorFocused
  interfaceOverviewVisible
  inReferenceSearchEditor
  referenceSearchVisible
  listFocus
  listSupportsMultiSelect
  listHasSelectionOrFocus
  listDoubleSelection
  listMultiSelection
  listSupportsKeyboardNavigation
  WorkbenchListAutomaticKeyboardNavigationKey
  accessibilityHelpWidgetVisible
  inQuickOpenKey
  supportedCodeAction
  hasSymbols
  hasSnippetCompletions
  messageVisible
  editorHasCallHierarchyProvider
  callHierarchyVisible
  searchViewletVisible
  searchViewletFocus
  inputBoxFocus
  searchInputBoxFocus
  replaceInputBoxFocus
  patternIncludesInputBoxFocus
  patternExcludesInputBoxFocus
  replaceActive
  hasSearchResult
  firstMatchFocus
  fileMatchOrMatchFocus
  fileMatchOrFolderMatchFocus
  fileMatchFocus
  folderMatchFocus
  matchFocus
  inRecentFilesPicker
  inWindowsPicker
  findWidgetVisible
  findInputFocussed
  replaceInputFocussed
  editorTextFocus
  editorFocus
  textInputFocus
  editorReadonly
  editorHasSelection
  editorHasMultipleSelections
  editorTabMoveFocus
  isInEmbeddedEditor
  canUndo
  canRedo
  editorLangId
  editorHasCompletionItemProvider
  editorHasCodeActionsProvider
  editorHasDefinitionProvider
  editorHasDeclarationProvider
  editorHasImplementationProvider
  editorHasTypeDefinitionProvider
  editorHasHoverProvider
  editorHadDocumentHighlightProvider
  editorHasDocumentSymbolProvider
  editorHasReferenceProvider
  editorHasRenameProvider
  editorHasSignatureHelpProvider
  editorHasDocumentFormattingProvider
  editorHasDocumentSelectionFormattingProvider
  editorHasMultipleDocumentSelectionFormattingProvider
  activeEditor
  editorIsOpen
  editorPinned
  groupActiveEditorDirty
  groupEditorsCount
  textCompareEditorVisible
  textCompareEditorActive
  activeEditorGroupEmpty
  multipleEditorGroups
  inZenMode
  inCenteredLayout
  splitEditorsVertically
  sideBarVisible
  sideBarFocus
  activeViewlet
  activePanel
  panelFocus
  panelPosition
  debugType
  debugConfigurationType
  debugState
  inDebugMode
  inDebugRepl
  breakpointWidgetVisible
  watchExpressionsFocused
  variablesFocused
  expressionSelected
  breakpointSelected
  callStackItemType
  loadedScriptsSupported
  loadedScriptsItemType
  focusedSessionIsAttach
  stepBackSupported
  restartFrameSupported
  inSettingsEditor
  inSettingsJSONEditor
  inSettingsSearch
  settingsTocRowFocus
  inKeybindings
  inKeybindingsSearch
  keybindingFocus
  explorerViewletVisible
  explorerResourceIsFolder
  explorerResourceReadonly
  explorerResourceIsRoot
  explorerResourceCut
  explorerResourceMoveableToTrash
  filesExplorerFocus
  openEditorsVisible
  openEditorsFocus
  explorerViewletFocus
  terminalIsOpen
  terminalFocus
  terminalTextSelected
  terminalFindWidgetVisible
  terminalFindWidgetInputFocused
  terminalFindWidgetFocused
  webviewFindWidgetVisible
  taskRunning
  referenceSearchTreeFocused
  interactivePlaygroundFocus
  outlineFiltered
  outlineFocused
  problemsViewFocus
  problemFocus
  problemsFilterFocus
  relatedInformationFocus
  inOutput
  activeLogOutput
  multiCursorModifier
  saveConflictResolutionContext
  markersNavigationVisible
  hasWordHighlights
  profileSessionState
  extensionHostProfileRecorded
  historyNavigationEnabled
  historyNavigationWidget
  nonEmptyWorkspace
  defaultExtensionViews
  searchMarketplaceExtensions
  searchInstalledExtensions
  searchOutdatedExtensions
  searchEnabledExtensions
  searchDisabledExtensions
  hasInstalledExtensions
  searchBuiltInExtensions
  recommendedExtensions
  defaultRecommendedExtensions
  workspaceRecommendations
  workspaceFolderRecommendations
  addToWorkspaceRecommendations
  addToWorkspaceFolderRecommendations
}
    `;
export const FinalConfigurationFragmentDoc = gql`
    fragment FinalConfiguration on Configuration {
  terminal {
    ...TerminalConfiguration
  }
  search {
    ...SearchConfiguration
  }
  languages {
    ...LanguagesConfiguration
  }
  output {
    maxChannelHistory
  }
  files {
    ...FilesConfiguration
  }
  git {
    ...GitConfiguration
  }
  workspace {
    ...WorkspaceConfiguration
  }
}
    ${TerminalConfigurationFragmentDoc}
${SearchConfigurationFragmentDoc}
${LanguagesConfigurationFragmentDoc}
${FilesConfigurationFragmentDoc}
${GitConfigurationFragmentDoc}
${WorkspaceConfigurationFragmentDoc}`;
export const KeybindingItemFragmentDoc = gql`
    fragment KeybindingItem on KeybindingItem {
  command
  key
  when
  source
}
    `;
export const KeybindingsFragmentDoc = gql`
    fragment Keybindings on Keybindings {
  items {
    command
    key
    when
    source
  }
}
    `;
export const PickItemFragmentDoc = gql`
    fragment pickItem on QuickPickItem {
  id
  label
  description
  detail
  keybinding {
    command
    key
    when
    source
  }
  italic
  highlights {
    label {
      start
      end
    }
    description {
      start
      end
    }
    detail {
      start
      end
    }
  }
  picked
  alwaysShow
}
    `;
export const SelectedFragmentDoc = gql`
    fragment selected on QuickInputModel {
  title
  inputValue
  selectedValue {
    ...pickItem
  }
}
    ${PickItemFragmentDoc}`;
export const ResourceContextFragmentDoc = gql`
    fragment ResourceContext on Context {
  resourceScheme
  resourceFilename
  resource
  resourceExtName
  resourceSet
  isFileSystemResource
}
    `;
export const StatusbarItemFragmentDoc = gql`
    fragment statusbarItem on StatusbarItem {
  ... on Terminal {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
  ... on SelectionStatus {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
  ... on Indentation {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
  ... on EncodingStatus {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
  ... on EndOfLineSequence {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
  ... on LanguageMode {
    name
    alignment
    entry {
      showTabsButtons
      showIcons
      showStatusbar
      text
      ariaLabel
      tooltip
      color
      backgroundColor
      command
      arguments
      showBeak
    }
    priority
  }
}
    `;
export const GetConfigurationDataFragmentDoc = gql`
    fragment GetConfigurationData on ConfigurationData {
  defaults {
    contents
    keys
    overrides {
      contents
      identifiers
    }
  }
  user {
    contents
    keys
    overrides {
      contents
      identifiers
    }
  }
  workspace {
    contents
    keys
    overrides {
      contents
      identifiers
    }
  }
  folders {
    id
    keys
    contents
    overrides {
      overrideIdentifier
      resource
    }
  }
}
    `;
export const INotificationMessageFragmentDoc = gql`
    fragment INotificationMessage on NotificationMessage {
  raw
  value
  links {
    name
    href
    offset
    length
  }
}
    `;
export const NotificationMessageFragmentDoc = gql`
    fragment NotificationMessage on NotificationMessage {
  ...INotificationMessage
  original {
    ...INotificationMessage
  }
}
    ${INotificationMessageFragmentDoc}`;
export const NotifyActionFragmentDoc = gql`
    fragment NotifyAction on Action {
  id
  label
  tooltip
  class
  enabled
  checked
  radio
}
    `;
export const NotificationFragmentDoc = gql`
    fragment Notification on Notification {
  index
  severity
  source
  actions {
    primary {
      ...NotifyAction
    }
    secondary {
      ...NotifyAction
    }
  }
  sticky
}
    ${NotifyActionFragmentDoc}`;
export const WorkspaceFolderFragmentDoc = gql`
    fragment WorkspaceFolder on WorkspaceFolderData {
  uri
  name
  index
}
    `;
export const InstallDocument = gql`
    mutation install($vsix: String!) {
  install(vsix: $vsix) {
    id
    uuid
  }
}
    `;

/**
 * __useInstallMutation__
 *
 * To run a mutation, you first call `useInstallMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useInstallMutation` 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 [installMutation, { data, loading, error }] = useInstallMutation({
 *   variables: {
 *      vsix: // value for 'vsix'
 *   },
 * });
 */
export function useInstallMutation(baseOptions?: Apollo.MutationHookOptions<IInstallMutation, IInstallMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IInstallMutation, IInstallMutationVariables>(InstallDocument, options);
      }
export type InstallMutationHookResult = ReturnType<typeof useInstallMutation>;
export type InstallMutationResult = Apollo.MutationResult<IInstallMutation>;
export type InstallMutationOptions = Apollo.BaseMutationOptions<IInstallMutation, IInstallMutationVariables>;
export const ProviderDefinitionDocument = gql`
    mutation providerDefinition($params: TextDocumentPositionParamsInput) {
  hoverProviderDefinition(params: $params) @client
}
    `;

/**
 * __useProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useProviderDefinitionMutation` 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 [providerDefinitionMutation, { data, loading, error }] = useProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IProviderDefinitionMutation, IProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IProviderDefinitionMutation, IProviderDefinitionMutationVariables>(ProviderDefinitionDocument, options);
      }
export type ProviderDefinitionMutationHookResult = ReturnType<typeof useProviderDefinitionMutation>;
export type ProviderDefinitionMutationResult = Apollo.MutationResult<IProviderDefinitionMutation>;
export type ProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IProviderDefinitionMutation, IProviderDefinitionMutationVariables>;
export const RemoveDocument = gql`
    mutation remove($id: String!) {
  removeExtension(id: $id)
}
    `;

/**
 * __useRemoveMutation__
 *
 * To run a mutation, you first call `useRemoveMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveMutation` 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 [removeMutation, { data, loading, error }] = useRemoveMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useRemoveMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveMutation, IRemoveMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRemoveMutation, IRemoveMutationVariables>(RemoveDocument, options);
      }
export type RemoveMutationHookResult = ReturnType<typeof useRemoveMutation>;
export type RemoveMutationResult = Apollo.MutationResult<IRemoveMutation>;
export type RemoveMutationOptions = Apollo.BaseMutationOptions<IRemoveMutation, IRemoveMutationVariables>;
export const ExtensionsByLimitDocument = gql`
    query ExtensionsByLimit($first: Int!, $prioritizeExtensionIDs: [String!]!) {
  extensionRegistry {
    extensions(first: $first, prioritizeExtensionIDs: $prioritizeExtensionIDs) {
      nodes {
        id
        url
        extensionID
        viewerCanAdminister
        manifest {
          raw
          name
          activationEvents
        }
      }
    }
  }
}
    `;

/**
 * __useExtensionsByLimitQuery__
 *
 * To run a query within a React component, call `useExtensionsByLimitQuery` and pass it any options that fit your needs.
 * When your component renders, `useExtensionsByLimitQuery` 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 } = useExtensionsByLimitQuery({
 *   variables: {
 *      first: // value for 'first'
 *      prioritizeExtensionIDs: // value for 'prioritizeExtensionIDs'
 *   },
 * });
 */
export function useExtensionsByLimitQuery(baseOptions: Apollo.QueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>(ExtensionsByLimitDocument, options);
      }
export function useExtensionsByLimitLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>(ExtensionsByLimitDocument, options);
        }
export type ExtensionsByLimitQueryHookResult = ReturnType<typeof useExtensionsByLimitQuery>;
export type ExtensionsByLimitLazyQueryHookResult = ReturnType<typeof useExtensionsByLimitLazyQuery>;
export type ExtensionsByLimitQueryResult = Apollo.QueryResult<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>;
export const ExtensionsDocument = gql`
    query Extensions {
  extensions {
    nodes {
      id
      url
      activationEvents
      viewerCanAdminister
      releases {
        version
        bundleURL
        extensionID
      }
      extensionID
      manifest {
        bundleURL
        raw
        name
        main
        badges
        preview
        version
        keywords
        license
        homepage
        publisher
        categories
        description
        extensionID
        displayName
        dependencies
        extensionDependencies
        bundle
        assets {
          Type
          Content
        }
        scripts {
          cdebasebuild
          cdebasepublish
        }
        bundles {
          server
          browser
        }
        extension {
          type
        }
        engines {
          node
          vscode
        }
        author {
          name
        }
        galleryBanner {
          color
          theme
        }
        activationEvents
        contributes {
          menus {
            commandPalette {
              action
              when
            }
            explorer {
              context {
                action
                when
              }
            }
            editor {
              context {
                action
                when
              }
              title {
                own {
                  action
                  when
                }
                context {
                  action
                  when
                }
              }
            }
          }
          actions {
            id
            command
            title
            category
            actionItem {
              label
              description
            }
          }
        }
      }
    }
  }
}
    `;

/**
 * __useExtensionsQuery__
 *
 * To run a query within a React component, call `useExtensionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useExtensionsQuery` 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 } = useExtensionsQuery({
 *   variables: {
 *   },
 * });
 */
export function useExtensionsQuery(baseOptions?: Apollo.QueryHookOptions<IExtensionsQuery, IExtensionsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IExtensionsQuery, IExtensionsQueryVariables>(ExtensionsDocument, options);
      }
export function useExtensionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IExtensionsQuery, IExtensionsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IExtensionsQuery, IExtensionsQueryVariables>(ExtensionsDocument, options);
        }
export type ExtensionsQueryHookResult = ReturnType<typeof useExtensionsQuery>;
export type ExtensionsLazyQueryHookResult = ReturnType<typeof useExtensionsLazyQuery>;
export type ExtensionsQueryResult = Apollo.QueryResult<IExtensionsQuery, IExtensionsQueryVariables>;
export const GalleryExtensionDocument = gql`
    query galleryExtension($extensionID: String!) {
  galleryExtension(extensionID: $extensionID) {
    id
    name
    icon
    version
    description
    publisher
    installCount
    publisherDisplayName
    rating
    ratingCount
    displayName
    assets {
      download {
        uri
        fallbackUri
      }
    }
    resources {
      icon
      readme
      manifest
      changelog
    }
  }
}
    `;

/**
 * __useGalleryExtensionQuery__
 *
 * To run a query within a React component, call `useGalleryExtensionQuery` and pass it any options that fit your needs.
 * When your component renders, `useGalleryExtensionQuery` 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 } = useGalleryExtensionQuery({
 *   variables: {
 *      extensionID: // value for 'extensionID'
 *   },
 * });
 */
export function useGalleryExtensionQuery(baseOptions: Apollo.QueryHookOptions<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>(GalleryExtensionDocument, options);
      }
export function useGalleryExtensionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>(GalleryExtensionDocument, options);
        }
export type GalleryExtensionQueryHookResult = ReturnType<typeof useGalleryExtensionQuery>;
export type GalleryExtensionLazyQueryHookResult = ReturnType<typeof useGalleryExtensionLazyQuery>;
export type GalleryExtensionQueryResult = Apollo.QueryResult<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>;
export const GalleryDocument = gql`
    query gallery($query: GalleryQueryInput) {
  gallery(query: $query) {
    page
    firstPage {
      id
      name
      icon
      version
      description
      publisher
      installCount
      publisherDisplayName
      rating
      ratingCount
      displayName
      assets {
        download {
          uri
          fallbackUri
        }
      }
    }
  }
}
    `;

/**
 * __useGalleryQuery__
 *
 * To run a query within a React component, call `useGalleryQuery` and pass it any options that fit your needs.
 * When your component renders, `useGalleryQuery` 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 } = useGalleryQuery({
 *   variables: {
 *      query: // value for 'query'
 *   },
 * });
 */
export function useGalleryQuery(baseOptions?: Apollo.QueryHookOptions<IGalleryQuery, IGalleryQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGalleryQuery, IGalleryQueryVariables>(GalleryDocument, options);
      }
export function useGalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGalleryQuery, IGalleryQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGalleryQuery, IGalleryQueryVariables>(GalleryDocument, options);
        }
export type GalleryQueryHookResult = ReturnType<typeof useGalleryQuery>;
export type GalleryLazyQueryHookResult = ReturnType<typeof useGalleryLazyQuery>;
export type GalleryQueryResult = Apollo.QueryResult<IGalleryQuery, IGalleryQueryVariables>;
export const InstalledExtensionsDocument = gql`
    query installedExtensions {
  installed {
    identifier {
      id
      uuid
    }
    galleryIdentifier {
      id
      uuid
    }
    extension {
      name
      id
      icon
      displayName
      installCount
      description
      version
      identifier {
        id
        uuid
      }
      publisherDisplayName
    }
  }
}
    `;

/**
 * __useInstalledExtensionsQuery__
 *
 * To run a query within a React component, call `useInstalledExtensionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useInstalledExtensionsQuery` 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 } = useInstalledExtensionsQuery({
 *   variables: {
 *   },
 * });
 */
export function useInstalledExtensionsQuery(baseOptions?: Apollo.QueryHookOptions<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>(InstalledExtensionsDocument, options);
      }
export function useInstalledExtensionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>(InstalledExtensionsDocument, options);
        }
export type InstalledExtensionsQueryHookResult = ReturnType<typeof useInstalledExtensionsQuery>;
export type InstalledExtensionsLazyQueryHookResult = ReturnType<typeof useInstalledExtensionsLazyQuery>;
export type InstalledExtensionsQueryResult = Apollo.QueryResult<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>;
export const ViewerSettingsDocument = gql`
    query ViewerSettings {
  viewerSettings {
    final
  }
}
    `;

/**
 * __useViewerSettingsQuery__
 *
 * To run a query within a React component, call `useViewerSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useViewerSettingsQuery` 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 } = useViewerSettingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useViewerSettingsQuery(baseOptions?: Apollo.QueryHookOptions<IViewerSettingsQuery, IViewerSettingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IViewerSettingsQuery, IViewerSettingsQueryVariables>(ViewerSettingsDocument, options);
      }
export function useViewerSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IViewerSettingsQuery, IViewerSettingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IViewerSettingsQuery, IViewerSettingsQueryVariables>(ViewerSettingsDocument, options);
        }
export type ViewerSettingsQueryHookResult = ReturnType<typeof useViewerSettingsQuery>;
export type ViewerSettingsLazyQueryHookResult = ReturnType<typeof useViewerSettingsLazyQuery>;
export type ViewerSettingsQueryResult = Apollo.QueryResult<IViewerSettingsQuery, IViewerSettingsQueryVariables>;
export const GetConfigurationTargetDocument = gql`
    mutation GetConfigurationTarget($resource: URI) {
  getConfigurationTarget(resource: $resource) @client
}
    `;

/**
 * __useGetConfigurationTargetMutation__
 *
 * To run a mutation, you first call `useGetConfigurationTargetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGetConfigurationTargetMutation` 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 [getConfigurationTargetMutation, { data, loading, error }] = useGetConfigurationTargetMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *   },
 * });
 */
export function useGetConfigurationTargetMutation(baseOptions?: Apollo.MutationHookOptions<IGetConfigurationTargetMutation, IGetConfigurationTargetMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IGetConfigurationTargetMutation, IGetConfigurationTargetMutationVariables>(GetConfigurationTargetDocument, options);
      }
export type GetConfigurationTargetMutationHookResult = ReturnType<typeof useGetConfigurationTargetMutation>;
export type GetConfigurationTargetMutationResult = Apollo.MutationResult<IGetConfigurationTargetMutation>;
export type GetConfigurationTargetMutationOptions = Apollo.BaseMutationOptions<IGetConfigurationTargetMutation, IGetConfigurationTargetMutationVariables>;
export const OpenGlobalKeybindingsSettingsDocument = gql`
    mutation OpenGlobalKeybindingsSettings($textual: Boolean) {
  openGlobalKeybindingSettings(textual: $textual) @client
}
    `;

/**
 * __useOpenGlobalKeybindingsSettingsMutation__
 *
 * To run a mutation, you first call `useOpenGlobalKeybindingsSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenGlobalKeybindingsSettingsMutation` 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 [openGlobalKeybindingsSettingsMutation, { data, loading, error }] = useOpenGlobalKeybindingsSettingsMutation({
 *   variables: {
 *      textual: // value for 'textual'
 *   },
 * });
 */
export function useOpenGlobalKeybindingsSettingsMutation(baseOptions?: Apollo.MutationHookOptions<IOpenGlobalKeybindingsSettingsMutation, IOpenGlobalKeybindingsSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenGlobalKeybindingsSettingsMutation, IOpenGlobalKeybindingsSettingsMutationVariables>(OpenGlobalKeybindingsSettingsDocument, options);
      }
export type OpenGlobalKeybindingsSettingsMutationHookResult = ReturnType<typeof useOpenGlobalKeybindingsSettingsMutation>;
export type OpenGlobalKeybindingsSettingsMutationResult = Apollo.MutationResult<IOpenGlobalKeybindingsSettingsMutation>;
export type OpenGlobalKeybindingsSettingsMutationOptions = Apollo.BaseMutationOptions<IOpenGlobalKeybindingsSettingsMutation, IOpenGlobalKeybindingsSettingsMutationVariables>;
export const OpenPreferenceSettingsDocument = gql`
    mutation OpenPreferenceSettings($jsonEditor: Boolean, $query: String) {
  openPreferenceSettings(jsonEditor: $jsonEditor, query: $query) @client
}
    `;

/**
 * __useOpenPreferenceSettingsMutation__
 *
 * To run a mutation, you first call `useOpenPreferenceSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenPreferenceSettingsMutation` 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 [openPreferenceSettingsMutation, { data, loading, error }] = useOpenPreferenceSettingsMutation({
 *   variables: {
 *      jsonEditor: // value for 'jsonEditor'
 *      query: // value for 'query'
 *   },
 * });
 */
export function useOpenPreferenceSettingsMutation(baseOptions?: Apollo.MutationHookOptions<IOpenPreferenceSettingsMutation, IOpenPreferenceSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenPreferenceSettingsMutation, IOpenPreferenceSettingsMutationVariables>(OpenPreferenceSettingsDocument, options);
      }
export type OpenPreferenceSettingsMutationHookResult = ReturnType<typeof useOpenPreferenceSettingsMutation>;
export type OpenPreferenceSettingsMutationResult = Apollo.MutationResult<IOpenPreferenceSettingsMutation>;
export type OpenPreferenceSettingsMutationOptions = Apollo.BaseMutationOptions<IOpenPreferenceSettingsMutation, IOpenPreferenceSettingsMutationVariables>;
export const ResetSettingDocument = gql`
    mutation ResetSetting($resource: URI, $settingKey: String) {
  resetSetting(resource: $resource, settingKey: $settingKey) @client
}
    `;

/**
 * __useResetSettingMutation__
 *
 * To run a mutation, you first call `useResetSettingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResetSettingMutation` 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 [resetSettingMutation, { data, loading, error }] = useResetSettingMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *      settingKey: // value for 'settingKey'
 *   },
 * });
 */
export function useResetSettingMutation(baseOptions?: Apollo.MutationHookOptions<IResetSettingMutation, IResetSettingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IResetSettingMutation, IResetSettingMutationVariables>(ResetSettingDocument, options);
      }
export type ResetSettingMutationHookResult = ReturnType<typeof useResetSettingMutation>;
export type ResetSettingMutationResult = Apollo.MutationResult<IResetSettingMutation>;
export type ResetSettingMutationOptions = Apollo.BaseMutationOptions<IResetSettingMutation, IResetSettingMutationVariables>;
export const SaveUserSettingsDocument = gql`
    mutation saveUserSettings($content: String) {
  saveUserSettings(content: $content) {
    id
  }
}
    `;

/**
 * __useSaveUserSettingsMutation__
 *
 * To run a mutation, you first call `useSaveUserSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSaveUserSettingsMutation` 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 [saveUserSettingsMutation, { data, loading, error }] = useSaveUserSettingsMutation({
 *   variables: {
 *      content: // value for 'content'
 *   },
 * });
 */
export function useSaveUserSettingsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveUserSettingsMutation, ISaveUserSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISaveUserSettingsMutation, ISaveUserSettingsMutationVariables>(SaveUserSettingsDocument, options);
      }
export type SaveUserSettingsMutationHookResult = ReturnType<typeof useSaveUserSettingsMutation>;
export type SaveUserSettingsMutationResult = Apollo.MutationResult<ISaveUserSettingsMutation>;
export type SaveUserSettingsMutationOptions = Apollo.BaseMutationOptions<ISaveUserSettingsMutation, ISaveUserSettingsMutationVariables>;
export const SaveWorkspaceSettingsDocument = gql`
    mutation saveWorkspaceSettings {
  saveWorkspaceSettings {
    updated
  }
}
    `;

/**
 * __useSaveWorkspaceSettingsMutation__
 *
 * To run a mutation, you first call `useSaveWorkspaceSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSaveWorkspaceSettingsMutation` 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 [saveWorkspaceSettingsMutation, { data, loading, error }] = useSaveWorkspaceSettingsMutation({
 *   variables: {
 *   },
 * });
 */
export function useSaveWorkspaceSettingsMutation(baseOptions?: Apollo.MutationHookOptions<ISaveWorkspaceSettingsMutation, ISaveWorkspaceSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISaveWorkspaceSettingsMutation, ISaveWorkspaceSettingsMutationVariables>(SaveWorkspaceSettingsDocument, options);
      }
export type SaveWorkspaceSettingsMutationHookResult = ReturnType<typeof useSaveWorkspaceSettingsMutation>;
export type SaveWorkspaceSettingsMutationResult = Apollo.MutationResult<ISaveWorkspaceSettingsMutation>;
export type SaveWorkspaceSettingsMutationOptions = Apollo.BaseMutationOptions<ISaveWorkspaceSettingsMutation, ISaveWorkspaceSettingsMutationVariables>;
export const SwitchSettingsDocument = gql`
    mutation SwitchSettings($target: Int, $editorId: Int, $resource: URI, $jsonEditor: Boolean) {
  switchSettings(
    target: $target
    editorId: $editorId
    resource: $resource
    jsonEditor: $jsonEditor
  ) @client
}
    `;

/**
 * __useSwitchSettingsMutation__
 *
 * To run a mutation, you first call `useSwitchSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSwitchSettingsMutation` 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 [switchSettingsMutation, { data, loading, error }] = useSwitchSettingsMutation({
 *   variables: {
 *      target: // value for 'target'
 *      editorId: // value for 'editorId'
 *      resource: // value for 'resource'
 *      jsonEditor: // value for 'jsonEditor'
 *   },
 * });
 */
export function useSwitchSettingsMutation(baseOptions?: Apollo.MutationHookOptions<ISwitchSettingsMutation, ISwitchSettingsMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISwitchSettingsMutation, ISwitchSettingsMutationVariables>(SwitchSettingsDocument, options);
      }
export type SwitchSettingsMutationHookResult = ReturnType<typeof useSwitchSettingsMutation>;
export type SwitchSettingsMutationResult = Apollo.MutationResult<ISwitchSettingsMutation>;
export type SwitchSettingsMutationOptions = Apollo.BaseMutationOptions<ISwitchSettingsMutation, ISwitchSettingsMutationVariables>;
export const DefaultPreferencesDocument = gql`
    query DefaultPreferences {
  defaultPreferences {
    preferences {
      type
      data {
        name
        type
        default
        description
        enum
        enumDescriptions
      }
    }
  }
}
    `;

/**
 * __useDefaultPreferencesQuery__
 *
 * To run a query within a React component, call `useDefaultPreferencesQuery` and pass it any options that fit your needs.
 * When your component renders, `useDefaultPreferencesQuery` 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 } = useDefaultPreferencesQuery({
 *   variables: {
 *   },
 * });
 */
export function useDefaultPreferencesQuery(baseOptions?: Apollo.QueryHookOptions<IDefaultPreferencesQuery, IDefaultPreferencesQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IDefaultPreferencesQuery, IDefaultPreferencesQueryVariables>(DefaultPreferencesDocument, options);
      }
export function useDefaultPreferencesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IDefaultPreferencesQuery, IDefaultPreferencesQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IDefaultPreferencesQuery, IDefaultPreferencesQueryVariables>(DefaultPreferencesDocument, options);
        }
export type DefaultPreferencesQueryHookResult = ReturnType<typeof useDefaultPreferencesQuery>;
export type DefaultPreferencesLazyQueryHookResult = ReturnType<typeof useDefaultPreferencesLazyQuery>;
export type DefaultPreferencesQueryResult = Apollo.QueryResult<IDefaultPreferencesQuery, IDefaultPreferencesQueryVariables>;
export const DefaultSettingsDocument = gql`
    query DefaultSettings($target: Int) {
  defaultViewerSettingsSubject(target: $target) {
    settingsCascade {
      finalConfiguration {
        defaultSetting {
          title
          id
          sections {
            settings {
              ...DefaultSetting
            }
          }
        }
      }
      final
    }
  }
}
    ${DefaultSettingFragmentDoc}`;

/**
 * __useDefaultSettingsQuery__
 *
 * To run a query within a React component, call `useDefaultSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useDefaultSettingsQuery` 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 } = useDefaultSettingsQuery({
 *   variables: {
 *      target: // value for 'target'
 *   },
 * });
 */
export function useDefaultSettingsQuery(baseOptions?: Apollo.QueryHookOptions<IDefaultSettingsQuery, IDefaultSettingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IDefaultSettingsQuery, IDefaultSettingsQueryVariables>(DefaultSettingsDocument, options);
      }
export function useDefaultSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IDefaultSettingsQuery, IDefaultSettingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IDefaultSettingsQuery, IDefaultSettingsQueryVariables>(DefaultSettingsDocument, options);
        }
export type DefaultSettingsQueryHookResult = ReturnType<typeof useDefaultSettingsQuery>;
export type DefaultSettingsLazyQueryHookResult = ReturnType<typeof useDefaultSettingsLazyQuery>;
export type DefaultSettingsQueryResult = Apollo.QueryResult<IDefaultSettingsQuery, IDefaultSettingsQueryVariables>;
export const FullConfigurationDocument = gql`
    query FullConfiguration {
  viewerSettings {
    final
    subjects {
      ... on UserSettings {
        id
        settingsURL
        latestSettings {
          contents
          createdAt
        }
        settingsCascade {
          finalConfiguration {
            terminal {
              ...TerminalConfiguration
            }
            search {
              ...SearchConfiguration
            }
            languages {
              ...LanguagesConfiguration
            }
            output {
              maxChannelHistory
            }
            files {
              ...FilesConfiguration
            }
            git {
              ...GitConfiguration
            }
            workspace {
              ...WorkspaceConfiguration
            }
          }
        }
      }
      ... on FolderSettings {
        id
        settingsURL
        latestSettings {
          contents
          createdAt
        }
        settingsCascade {
          finalConfiguration {
            terminal {
              ...TerminalConfiguration
            }
            search {
              ...SearchConfiguration
            }
            languages {
              ...LanguagesConfiguration
            }
            output {
              maxChannelHistory
            }
            files {
              ...FilesConfiguration
            }
            git {
              ...GitConfiguration
            }
            workspace {
              ...WorkspaceConfiguration
            }
          }
        }
      }
      ... on GlobalSettings {
        id
        settingsURL
        latestSettings {
          contents
          createdAt
        }
        settingsCascade {
          finalConfiguration {
            terminal {
              ...TerminalConfiguration
            }
            search {
              ...SearchConfiguration
            }
            languages {
              ...LanguagesConfiguration
            }
            output {
              maxChannelHistory
            }
            files {
              ...FilesConfiguration
            }
            git {
              ...GitConfiguration
            }
            workspace {
              ...WorkspaceConfiguration
            }
          }
        }
      }
      ... on WorkspaceSettings {
        id
        settingsURL
        latestSettings {
          contents
          createdAt
        }
        settingsCascade {
          finalConfiguration {
            terminal {
              ...TerminalConfiguration
            }
            search {
              ...SearchConfiguration
            }
            languages {
              ...LanguagesConfiguration
            }
            output {
              maxChannelHistory
            }
            files {
              ...FilesConfiguration
            }
            git {
              ...GitConfiguration
            }
            workspace {
              ...WorkspaceConfiguration
            }
          }
        }
      }
    }
  }
}
    ${TerminalConfigurationFragmentDoc}
${SearchConfigurationFragmentDoc}
${LanguagesConfigurationFragmentDoc}
${FilesConfigurationFragmentDoc}
${GitConfigurationFragmentDoc}
${WorkspaceConfigurationFragmentDoc}`;

/**
 * __useFullConfigurationQuery__
 *
 * To run a query within a React component, call `useFullConfigurationQuery` and pass it any options that fit your needs.
 * When your component renders, `useFullConfigurationQuery` 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 } = useFullConfigurationQuery({
 *   variables: {
 *   },
 * });
 */
export function useFullConfigurationQuery(baseOptions?: Apollo.QueryHookOptions<IFullConfigurationQuery, IFullConfigurationQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IFullConfigurationQuery, IFullConfigurationQueryVariables>(FullConfigurationDocument, options);
      }
export function useFullConfigurationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFullConfigurationQuery, IFullConfigurationQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IFullConfigurationQuery, IFullConfigurationQueryVariables>(FullConfigurationDocument, options);
        }
export type FullConfigurationQueryHookResult = ReturnType<typeof useFullConfigurationQuery>;
export type FullConfigurationLazyQueryHookResult = ReturnType<typeof useFullConfigurationLazyQuery>;
export type FullConfigurationQueryResult = Apollo.QueryResult<IFullConfigurationQuery, IFullConfigurationQueryVariables>;
export const GetMostCommonlyUsedSettingsDocument = gql`
    query GetMostCommonlyUsedSettings {
  getMostCommonlyUsedSettings @client
}
    `;

/**
 * __useGetMostCommonlyUsedSettingsQuery__
 *
 * To run a query within a React component, call `useGetMostCommonlyUsedSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMostCommonlyUsedSettingsQuery` 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 } = useGetMostCommonlyUsedSettingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetMostCommonlyUsedSettingsQuery(baseOptions?: Apollo.QueryHookOptions<IGetMostCommonlyUsedSettingsQuery, IGetMostCommonlyUsedSettingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetMostCommonlyUsedSettingsQuery, IGetMostCommonlyUsedSettingsQueryVariables>(GetMostCommonlyUsedSettingsDocument, options);
      }
export function useGetMostCommonlyUsedSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetMostCommonlyUsedSettingsQuery, IGetMostCommonlyUsedSettingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetMostCommonlyUsedSettingsQuery, IGetMostCommonlyUsedSettingsQueryVariables>(GetMostCommonlyUsedSettingsDocument, options);
        }
export type GetMostCommonlyUsedSettingsQueryHookResult = ReturnType<typeof useGetMostCommonlyUsedSettingsQuery>;
export type GetMostCommonlyUsedSettingsLazyQueryHookResult = ReturnType<typeof useGetMostCommonlyUsedSettingsLazyQuery>;
export type GetMostCommonlyUsedSettingsQueryResult = Apollo.QueryResult<IGetMostCommonlyUsedSettingsQuery, IGetMostCommonlyUsedSettingsQueryVariables>;
export const WorkspacesDocument = gql`
    query Workspaces {
  workspaces {
    uri
  }
}
    `;

/**
 * __useWorkspacesQuery__
 *
 * To run a query within a React component, call `useWorkspacesQuery` and pass it any options that fit your needs.
 * When your component renders, `useWorkspacesQuery` 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 } = useWorkspacesQuery({
 *   variables: {
 *   },
 * });
 */
export function useWorkspacesQuery(baseOptions?: Apollo.QueryHookOptions<IWorkspacesQuery, IWorkspacesQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IWorkspacesQuery, IWorkspacesQueryVariables>(WorkspacesDocument, options);
      }
export function useWorkspacesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IWorkspacesQuery, IWorkspacesQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IWorkspacesQuery, IWorkspacesQueryVariables>(WorkspacesDocument, options);
        }
export type WorkspacesQueryHookResult = ReturnType<typeof useWorkspacesQuery>;
export type WorkspacesLazyQueryHookResult = ReturnType<typeof useWorkspacesLazyQuery>;
export type WorkspacesQueryResult = Apollo.QueryResult<IWorkspacesQuery, IWorkspacesQueryVariables>;
export const UpdateConfigurationValueDocument = gql`
    mutation UpdateConfigurationValue($key: String!, $value: AnyObject!, $overrides: ConfigurationOverrides_Input!, $target: Int, $donotNotifyError: Boolean) {
  updateConfigurationValue(
    key: $key
    value: $value
    overrides: $overrides
    target: $target
    donotNotifyError: $donotNotifyError
  )
}
    `;

/**
 * __useUpdateConfigurationValueMutation__
 *
 * To run a mutation, you first call `useUpdateConfigurationValueMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateConfigurationValueMutation` 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 [updateConfigurationValueMutation, { data, loading, error }] = useUpdateConfigurationValueMutation({
 *   variables: {
 *      key: // value for 'key'
 *      value: // value for 'value'
 *      overrides: // value for 'overrides'
 *      target: // value for 'target'
 *      donotNotifyError: // value for 'donotNotifyError'
 *   },
 * });
 */
export function useUpdateConfigurationValueMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateConfigurationValueMutation, IUpdateConfigurationValueMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateConfigurationValueMutation, IUpdateConfigurationValueMutationVariables>(UpdateConfigurationValueDocument, options);
      }
export type UpdateConfigurationValueMutationHookResult = ReturnType<typeof useUpdateConfigurationValueMutation>;
export type UpdateConfigurationValueMutationResult = Apollo.MutationResult<IUpdateConfigurationValueMutation>;
export type UpdateConfigurationValueMutationOptions = Apollo.BaseMutationOptions<IUpdateConfigurationValueMutation, IUpdateConfigurationValueMutationVariables>;
export const CopyDocument = gql`
    mutation Copy($value: String) {
  copy(value: $value) @client
}
    `;

/**
 * __useCopyMutation__
 *
 * To run a mutation, you first call `useCopyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCopyMutation` 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 [copyMutation, { data, loading, error }] = useCopyMutation({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export function useCopyMutation(baseOptions?: Apollo.MutationHookOptions<ICopyMutation, ICopyMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ICopyMutation, ICopyMutationVariables>(CopyDocument, options);
      }
export type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
export type CopyMutationResult = Apollo.MutationResult<ICopyMutation>;
export type CopyMutationOptions = Apollo.BaseMutationOptions<ICopyMutation, ICopyMutationVariables>;
export const RunMenuActionDocument = gql`
    mutation RunMenuAction($argument: ActionRunInput) {
  runMenuAction(argument: $argument) @client
}
    `;

/**
 * __useRunMenuActionMutation__
 *
 * To run a mutation, you first call `useRunMenuActionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRunMenuActionMutation` 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 [runMenuActionMutation, { data, loading, error }] = useRunMenuActionMutation({
 *   variables: {
 *      argument: // value for 'argument'
 *   },
 * });
 */
export function useRunMenuActionMutation(baseOptions?: Apollo.MutationHookOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRunMenuActionMutation, IRunMenuActionMutationVariables>(RunMenuActionDocument, options);
      }
export type RunMenuActionMutationHookResult = ReturnType<typeof useRunMenuActionMutation>;
export type RunMenuActionMutationResult = Apollo.MutationResult<IRunMenuActionMutation>;
export type RunMenuActionMutationOptions = Apollo.BaseMutationOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>;
export const HideContextMenuDocument = gql`
    mutation HideContextMenu {
  hideContextMenu @client
}
    `;

/**
 * __useHideContextMenuMutation__
 *
 * To run a mutation, you first call `useHideContextMenuMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideContextMenuMutation` 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 [hideContextMenuMutation, { data, loading, error }] = useHideContextMenuMutation({
 *   variables: {
 *   },
 * });
 */
export function useHideContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHideContextMenuMutation, IHideContextMenuMutationVariables>(HideContextMenuDocument, options);
      }
export type HideContextMenuMutationHookResult = ReturnType<typeof useHideContextMenuMutation>;
export type HideContextMenuMutationResult = Apollo.MutationResult<IHideContextMenuMutation>;
export type HideContextMenuMutationOptions = Apollo.BaseMutationOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>;
export const ShowContextMenuDocument = gql`
    mutation ShowContextMenu($delegate: ContextMenuInput) {
  showContextMenu(delegate: $delegate) @client
}
    `;

/**
 * __useShowContextMenuMutation__
 *
 * To run a mutation, you first call `useShowContextMenuMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowContextMenuMutation` 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 [showContextMenuMutation, { data, loading, error }] = useShowContextMenuMutation({
 *   variables: {
 *      delegate: // value for 'delegate'
 *   },
 * });
 */
export function useShowContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IShowContextMenuMutation, IShowContextMenuMutationVariables>(ShowContextMenuDocument, options);
      }
export type ShowContextMenuMutationHookResult = ReturnType<typeof useShowContextMenuMutation>;
export type ShowContextMenuMutationResult = Apollo.MutationResult<IShowContextMenuMutation>;
export type ShowContextMenuMutationOptions = Apollo.BaseMutationOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>;
export const CloseDialogDocument = gql`
    mutation CloseDialog {
  closeDialog @client
}
    `;

/**
 * __useCloseDialogMutation__
 *
 * To run a mutation, you first call `useCloseDialogMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCloseDialogMutation` 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 [closeDialogMutation, { data, loading, error }] = useCloseDialogMutation({
 *   variables: {
 *   },
 * });
 */
export function useCloseDialogMutation(baseOptions?: Apollo.MutationHookOptions<ICloseDialogMutation, ICloseDialogMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ICloseDialogMutation, ICloseDialogMutationVariables>(CloseDialogDocument, options);
      }
export type CloseDialogMutationHookResult = ReturnType<typeof useCloseDialogMutation>;
export type CloseDialogMutationResult = Apollo.MutationResult<ICloseDialogMutation>;
export type CloseDialogMutationOptions = Apollo.BaseMutationOptions<ICloseDialogMutation, ICloseDialogMutationVariables>;
export const ShowDocument = gql`
    mutation Show($dialog: DialogInput) {
  show(dialog: $dialog) @client
}
    `;

/**
 * __useShowMutation__
 *
 * To run a mutation, you first call `useShowMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowMutation` 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 [showMutation, { data, loading, error }] = useShowMutation({
 *   variables: {
 *      dialog: // value for 'dialog'
 *   },
 * });
 */
export function useShowMutation(baseOptions?: Apollo.MutationHookOptions<IShowMutation, IShowMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IShowMutation, IShowMutationVariables>(ShowDocument, options);
      }
export type ShowMutationHookResult = ReturnType<typeof useShowMutation>;
export type ShowMutationResult = Apollo.MutationResult<IShowMutation>;
export type ShowMutationOptions = Apollo.BaseMutationOptions<IShowMutation, IShowMutationVariables>;
export const OpenEditorResourceInputDocument = gql`
    mutation OpenEditorResourceInput($editor: Resource_Input!, $group: Int) {
  openEditorWithResourceInput(editor: $editor, group: $group) @client
}
    `;

/**
 * __useOpenEditorResourceInputMutation__
 *
 * To run a mutation, you first call `useOpenEditorResourceInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorResourceInputMutation` 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 [openEditorResourceInputMutation, { data, loading, error }] = useOpenEditorResourceInputMutation({
 *   variables: {
 *      editor: // value for 'editor'
 *      group: // value for 'group'
 *   },
 * });
 */
export function useOpenEditorResourceInputMutation(baseOptions?: Apollo.MutationHookOptions<IOpenEditorResourceInputMutation, IOpenEditorResourceInputMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenEditorResourceInputMutation, IOpenEditorResourceInputMutationVariables>(OpenEditorResourceInputDocument, options);
      }
export type OpenEditorResourceInputMutationHookResult = ReturnType<typeof useOpenEditorResourceInputMutation>;
export type OpenEditorResourceInputMutationResult = Apollo.MutationResult<IOpenEditorResourceInputMutation>;
export type OpenEditorResourceInputMutationOptions = Apollo.BaseMutationOptions<IOpenEditorResourceInputMutation, IOpenEditorResourceInputMutationVariables>;
export const OpenEditorDocument = gql`
    mutation OpenEditor($content: OpenEditor_Input!, $options: EditorOpenOptions_Input) {
  openEditor(content: $content, options: $options) @client
}
    `;

/**
 * __useOpenEditorMutation__
 *
 * To run a mutation, you first call `useOpenEditorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorMutation` 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 [openEditorMutation, { data, loading, error }] = useOpenEditorMutation({
 *   variables: {
 *      content: // value for 'content'
 *      options: // value for 'options'
 *   },
 * });
 */
export function useOpenEditorMutation(baseOptions?: Apollo.MutationHookOptions<IOpenEditorMutation, IOpenEditorMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenEditorMutation, IOpenEditorMutationVariables>(OpenEditorDocument, options);
      }
export type OpenEditorMutationHookResult = ReturnType<typeof useOpenEditorMutation>;
export type OpenEditorMutationResult = Apollo.MutationResult<IOpenEditorMutation>;
export type OpenEditorMutationOptions = Apollo.BaseMutationOptions<IOpenEditorMutation, IOpenEditorMutationVariables>;
export const GoToLineDocument = gql`
    mutation GoToLine($range: LineRangeInput) {
  gotoLine(range: $range) @client
}
    `;

/**
 * __useGoToLineMutation__
 *
 * To run a mutation, you first call `useGoToLineMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGoToLineMutation` 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 [goToLineMutation, { data, loading, error }] = useGoToLineMutation({
 *   variables: {
 *      range: // value for 'range'
 *   },
 * });
 */
export function useGoToLineMutation(baseOptions?: Apollo.MutationHookOptions<IGoToLineMutation, IGoToLineMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IGoToLineMutation, IGoToLineMutationVariables>(GoToLineDocument, options);
      }
export type GoToLineMutationHookResult = ReturnType<typeof useGoToLineMutation>;
export type GoToLineMutationResult = Apollo.MutationResult<IGoToLineMutation>;
export type GoToLineMutationOptions = Apollo.BaseMutationOptions<IGoToLineMutation, IGoToLineMutationVariables>;
export const HighlightLineDocument = gql`
    mutation HighlightLine($range: LineRangeInput) {
  highlightLine(range: $range) @client
}
    `;

/**
 * __useHighlightLineMutation__
 *
 * To run a mutation, you first call `useHighlightLineMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHighlightLineMutation` 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 [highlightLineMutation, { data, loading, error }] = useHighlightLineMutation({
 *   variables: {
 *      range: // value for 'range'
 *   },
 * });
 */
export function useHighlightLineMutation(baseOptions?: Apollo.MutationHookOptions<IHighlightLineMutation, IHighlightLineMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHighlightLineMutation, IHighlightLineMutationVariables>(HighlightLineDocument, options);
      }
export type HighlightLineMutationHookResult = ReturnType<typeof useHighlightLineMutation>;
export type HighlightLineMutationResult = Apollo.MutationResult<IHighlightLineMutation>;
export type HighlightLineMutationOptions = Apollo.BaseMutationOptions<IHighlightLineMutation, IHighlightLineMutationVariables>;
export const JsonEditingWriteDocument = gql`
    mutation JsonEditingWrite($resource: URI, $value: IJSONValueInput, $save: Boolean) {
  jsonWrite(resource: $resource, value: $value, save: $save)
}
    `;

/**
 * __useJsonEditingWriteMutation__
 *
 * To run a mutation, you first call `useJsonEditingWriteMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useJsonEditingWriteMutation` 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 [jsonEditingWriteMutation, { data, loading, error }] = useJsonEditingWriteMutation({
 *   variables: {
 *      resource: // value for 'resource'
 *      value: // value for 'value'
 *      save: // value for 'save'
 *   },
 * });
 */
export function useJsonEditingWriteMutation(baseOptions?: Apollo.MutationHookOptions<IJsonEditingWriteMutation, IJsonEditingWriteMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IJsonEditingWriteMutation, IJsonEditingWriteMutationVariables>(JsonEditingWriteDocument, options);
      }
export type JsonEditingWriteMutationHookResult = ReturnType<typeof useJsonEditingWriteMutation>;
export type JsonEditingWriteMutationResult = Apollo.MutationResult<IJsonEditingWriteMutation>;
export type JsonEditingWriteMutationOptions = Apollo.BaseMutationOptions<IJsonEditingWriteMutation, IJsonEditingWriteMutationVariables>;
export const ChangeKeybindingDocument = gql`
    mutation ChangeKeybinding($editItem: KeybindingItemInput, $selectedIndex: Int, $isOpenDialog: Boolean) {
  changeKeybinding(
    editItem: $editItem
    selectedIndex: $selectedIndex
    isOpenDialog: $isOpenDialog
  ) @client
}
    `;

/**
 * __useChangeKeybindingMutation__
 *
 * To run a mutation, you first call `useChangeKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeKeybindingMutation` 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 [changeKeybindingMutation, { data, loading, error }] = useChangeKeybindingMutation({
 *   variables: {
 *      editItem: // value for 'editItem'
 *      selectedIndex: // value for 'selectedIndex'
 *      isOpenDialog: // value for 'isOpenDialog'
 *   },
 * });
 */
export function useChangeKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<IChangeKeybindingMutation, IChangeKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IChangeKeybindingMutation, IChangeKeybindingMutationVariables>(ChangeKeybindingDocument, options);
      }
export type ChangeKeybindingMutationHookResult = ReturnType<typeof useChangeKeybindingMutation>;
export type ChangeKeybindingMutationResult = Apollo.MutationResult<IChangeKeybindingMutation>;
export type ChangeKeybindingMutationOptions = Apollo.BaseMutationOptions<IChangeKeybindingMutation, IChangeKeybindingMutationVariables>;
export const ChangeWhenExpressionDocument = gql`
    mutation ChangeWhenExpression($editItem: KeybindingItemInput, $editWhenIndex: Int, $newWhen: String) {
  changeWhenExpression(
    editItem: $editItem
    editWhenIndex: $editWhenIndex
    newWhen: $newWhen
  ) @client
}
    `;

/**
 * __useChangeWhenExpressionMutation__
 *
 * To run a mutation, you first call `useChangeWhenExpressionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeWhenExpressionMutation` 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 [changeWhenExpressionMutation, { data, loading, error }] = useChangeWhenExpressionMutation({
 *   variables: {
 *      editItem: // value for 'editItem'
 *      editWhenIndex: // value for 'editWhenIndex'
 *      newWhen: // value for 'newWhen'
 *   },
 * });
 */
export function useChangeWhenExpressionMutation(baseOptions?: Apollo.MutationHookOptions<IChangeWhenExpressionMutation, IChangeWhenExpressionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IChangeWhenExpressionMutation, IChangeWhenExpressionMutationVariables>(ChangeWhenExpressionDocument, options);
      }
export type ChangeWhenExpressionMutationHookResult = ReturnType<typeof useChangeWhenExpressionMutation>;
export type ChangeWhenExpressionMutationResult = Apollo.MutationResult<IChangeWhenExpressionMutation>;
export type ChangeWhenExpressionMutationOptions = Apollo.BaseMutationOptions<IChangeWhenExpressionMutation, IChangeWhenExpressionMutationVariables>;
export const EditKeybindingDocument = gql`
    mutation EditKeybinding($keybindingItem: KeybindingItemInput, $key: String, $when: String) {
  editKeybinding(keybindingItem: $keybindingItem, key: $key, when: $when) @client
}
    `;

/**
 * __useEditKeybindingMutation__
 *
 * To run a mutation, you first call `useEditKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditKeybindingMutation` 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 [editKeybindingMutation, { data, loading, error }] = useEditKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *      key: // value for 'key'
 *      when: // value for 'when'
 *   },
 * });
 */
export function useEditKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<IEditKeybindingMutation, IEditKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IEditKeybindingMutation, IEditKeybindingMutationVariables>(EditKeybindingDocument, options);
      }
export type EditKeybindingMutationHookResult = ReturnType<typeof useEditKeybindingMutation>;
export type EditKeybindingMutationResult = Apollo.MutationResult<IEditKeybindingMutation>;
export type EditKeybindingMutationOptions = Apollo.BaseMutationOptions<IEditKeybindingMutation, IEditKeybindingMutationVariables>;
export const HideKeybindingDialogDocument = gql`
    mutation HideKeybindingDialog {
  hideKeybindingDialog @client
}
    `;

/**
 * __useHideKeybindingDialogMutation__
 *
 * To run a mutation, you first call `useHideKeybindingDialogMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideKeybindingDialogMutation` 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 [hideKeybindingDialogMutation, { data, loading, error }] = useHideKeybindingDialogMutation({
 *   variables: {
 *   },
 * });
 */
export function useHideKeybindingDialogMutation(baseOptions?: Apollo.MutationHookOptions<IHideKeybindingDialogMutation, IHideKeybindingDialogMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHideKeybindingDialogMutation, IHideKeybindingDialogMutationVariables>(HideKeybindingDialogDocument, options);
      }
export type HideKeybindingDialogMutationHookResult = ReturnType<typeof useHideKeybindingDialogMutation>;
export type HideKeybindingDialogMutationResult = Apollo.MutationResult<IHideKeybindingDialogMutation>;
export type HideKeybindingDialogMutationOptions = Apollo.BaseMutationOptions<IHideKeybindingDialogMutation, IHideKeybindingDialogMutationVariables>;
export const LookupKeybindingDocument = gql`
    mutation LookupKeybinding($commandId: String) {
  lookupKeybinding(commandId: $commandId) @client
}
    `;

/**
 * __useLookupKeybindingMutation__
 *
 * To run a mutation, you first call `useLookupKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useLookupKeybindingMutation` 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 [lookupKeybindingMutation, { data, loading, error }] = useLookupKeybindingMutation({
 *   variables: {
 *      commandId: // value for 'commandId'
 *   },
 * });
 */
export function useLookupKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<ILookupKeybindingMutation, ILookupKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ILookupKeybindingMutation, ILookupKeybindingMutationVariables>(LookupKeybindingDocument, options);
      }
export type LookupKeybindingMutationHookResult = ReturnType<typeof useLookupKeybindingMutation>;
export type LookupKeybindingMutationResult = Apollo.MutationResult<ILookupKeybindingMutation>;
export type LookupKeybindingMutationOptions = Apollo.BaseMutationOptions<ILookupKeybindingMutation, ILookupKeybindingMutationVariables>;
export const RegisterKeybindingDocument = gql`
    mutation registerKeybinding($keybinding: KeybindingInput) {
  registerKeybinding(keybinding: $keybinding) @client
}
    `;

/**
 * __useRegisterKeybindingMutation__
 *
 * To run a mutation, you first call `useRegisterKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRegisterKeybindingMutation` 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 [registerKeybindingMutation, { data, loading, error }] = useRegisterKeybindingMutation({
 *   variables: {
 *      keybinding: // value for 'keybinding'
 *   },
 * });
 */
export function useRegisterKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<IRegisterKeybindingMutation, IRegisterKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRegisterKeybindingMutation, IRegisterKeybindingMutationVariables>(RegisterKeybindingDocument, options);
      }
export type RegisterKeybindingMutationHookResult = ReturnType<typeof useRegisterKeybindingMutation>;
export type RegisterKeybindingMutationResult = Apollo.MutationResult<IRegisterKeybindingMutation>;
export type RegisterKeybindingMutationOptions = Apollo.BaseMutationOptions<IRegisterKeybindingMutation, IRegisterKeybindingMutationVariables>;
export const RemoveKeybindingDocument = gql`
    mutation RemoveKeybinding($keybindingItem: KeybindingItemInput) {
  removeKeybinding(keybindingItem: $keybindingItem) @client
}
    `;

/**
 * __useRemoveKeybindingMutation__
 *
 * To run a mutation, you first call `useRemoveKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveKeybindingMutation` 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 [removeKeybindingMutation, { data, loading, error }] = useRemoveKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *   },
 * });
 */
export function useRemoveKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveKeybindingMutation, IRemoveKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRemoveKeybindingMutation, IRemoveKeybindingMutationVariables>(RemoveKeybindingDocument, options);
      }
export type RemoveKeybindingMutationHookResult = ReturnType<typeof useRemoveKeybindingMutation>;
export type RemoveKeybindingMutationResult = Apollo.MutationResult<IRemoveKeybindingMutation>;
export type RemoveKeybindingMutationOptions = Apollo.BaseMutationOptions<IRemoveKeybindingMutation, IRemoveKeybindingMutationVariables>;
export const ResetKeybindingDocument = gql`
    mutation ResetKeybinding($keybindingItem: KeybindingItemInput) {
  resetKeybinding(keybindingItem: $keybindingItem) @client
}
    `;

/**
 * __useResetKeybindingMutation__
 *
 * To run a mutation, you first call `useResetKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResetKeybindingMutation` 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 [resetKeybindingMutation, { data, loading, error }] = useResetKeybindingMutation({
 *   variables: {
 *      keybindingItem: // value for 'keybindingItem'
 *   },
 * });
 */
export function useResetKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<IResetKeybindingMutation, IResetKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IResetKeybindingMutation, IResetKeybindingMutationVariables>(ResetKeybindingDocument, options);
      }
export type ResetKeybindingMutationHookResult = ReturnType<typeof useResetKeybindingMutation>;
export type ResetKeybindingMutationResult = Apollo.MutationResult<IResetKeybindingMutation>;
export type ResetKeybindingMutationOptions = Apollo.BaseMutationOptions<IResetKeybindingMutation, IResetKeybindingMutationVariables>;
export const ResolveKeyboardEventDocument = gql`
    mutation ResolveKeyboardEvent($keyboardEvent: KeyboardEventInput) {
  resolveKeyboardEvent(keyboardEvent: $keyboardEvent) @client {
    label
    key
  }
}
    `;

/**
 * __useResolveKeyboardEventMutation__
 *
 * To run a mutation, you first call `useResolveKeyboardEventMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResolveKeyboardEventMutation` 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 [resolveKeyboardEventMutation, { data, loading, error }] = useResolveKeyboardEventMutation({
 *   variables: {
 *      keyboardEvent: // value for 'keyboardEvent'
 *   },
 * });
 */
export function useResolveKeyboardEventMutation(baseOptions?: Apollo.MutationHookOptions<IResolveKeyboardEventMutation, IResolveKeyboardEventMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IResolveKeyboardEventMutation, IResolveKeyboardEventMutationVariables>(ResolveKeyboardEventDocument, options);
      }
export type ResolveKeyboardEventMutationHookResult = ReturnType<typeof useResolveKeyboardEventMutation>;
export type ResolveKeyboardEventMutationResult = Apollo.MutationResult<IResolveKeyboardEventMutation>;
export type ResolveKeyboardEventMutationOptions = Apollo.BaseMutationOptions<IResolveKeyboardEventMutation, IResolveKeyboardEventMutationVariables>;
export const SearchKeybindingDocument = gql`
    mutation SearchKeybinding($value: String) {
  searchKeybinding(value: $value) @client
}
    `;

/**
 * __useSearchKeybindingMutation__
 *
 * To run a mutation, you first call `useSearchKeybindingMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSearchKeybindingMutation` 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 [searchKeybindingMutation, { data, loading, error }] = useSearchKeybindingMutation({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export function useSearchKeybindingMutation(baseOptions?: Apollo.MutationHookOptions<ISearchKeybindingMutation, ISearchKeybindingMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISearchKeybindingMutation, ISearchKeybindingMutationVariables>(SearchKeybindingDocument, options);
      }
export type SearchKeybindingMutationHookResult = ReturnType<typeof useSearchKeybindingMutation>;
export type SearchKeybindingMutationResult = Apollo.MutationResult<ISearchKeybindingMutation>;
export type SearchKeybindingMutationOptions = Apollo.BaseMutationOptions<ISearchKeybindingMutation, ISearchKeybindingMutationVariables>;
export const SetSelectedKeybindingIndexDocument = gql`
    mutation SetSelectedKeybindingIndex($index: Int) {
  setSelectedKeybindingIndex(index: $index) @client
}
    `;

/**
 * __useSetSelectedKeybindingIndexMutation__
 *
 * To run a mutation, you first call `useSetSelectedKeybindingIndexMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetSelectedKeybindingIndexMutation` 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 [setSelectedKeybindingIndexMutation, { data, loading, error }] = useSetSelectedKeybindingIndexMutation({
 *   variables: {
 *      index: // value for 'index'
 *   },
 * });
 */
export function useSetSelectedKeybindingIndexMutation(baseOptions?: Apollo.MutationHookOptions<ISetSelectedKeybindingIndexMutation, ISetSelectedKeybindingIndexMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISetSelectedKeybindingIndexMutation, ISetSelectedKeybindingIndexMutationVariables>(SetSelectedKeybindingIndexDocument, options);
      }
export type SetSelectedKeybindingIndexMutationHookResult = ReturnType<typeof useSetSelectedKeybindingIndexMutation>;
export type SetSelectedKeybindingIndexMutationResult = Apollo.MutationResult<ISetSelectedKeybindingIndexMutation>;
export type SetSelectedKeybindingIndexMutationOptions = Apollo.BaseMutationOptions<ISetSelectedKeybindingIndexMutation, ISetSelectedKeybindingIndexMutationVariables>;
export const StopEditWhenExpressionDocument = gql`
    mutation StopEditWhenExpression {
  stopEditWhenExpression @client
}
    `;

/**
 * __useStopEditWhenExpressionMutation__
 *
 * To run a mutation, you first call `useStopEditWhenExpressionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStopEditWhenExpressionMutation` 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 [stopEditWhenExpressionMutation, { data, loading, error }] = useStopEditWhenExpressionMutation({
 *   variables: {
 *   },
 * });
 */
export function useStopEditWhenExpressionMutation(baseOptions?: Apollo.MutationHookOptions<IStopEditWhenExpressionMutation, IStopEditWhenExpressionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IStopEditWhenExpressionMutation, IStopEditWhenExpressionMutationVariables>(StopEditWhenExpressionDocument, options);
      }
export type StopEditWhenExpressionMutationHookResult = ReturnType<typeof useStopEditWhenExpressionMutation>;
export type StopEditWhenExpressionMutationResult = Apollo.MutationResult<IStopEditWhenExpressionMutation>;
export type StopEditWhenExpressionMutationOptions = Apollo.BaseMutationOptions<IStopEditWhenExpressionMutation, IStopEditWhenExpressionMutationVariables>;
export const AddNotificationDocument = gql`
    mutation AddNotification($notification: NotificationInput) {
  addNotification(notification: $notification) @client
}
    `;

/**
 * __useAddNotificationMutation__
 *
 * To run a mutation, you first call `useAddNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddNotificationMutation` 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 [addNotificationMutation, { data, loading, error }] = useAddNotificationMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export function useAddNotificationMutation(baseOptions?: Apollo.MutationHookOptions<IAddNotificationMutation, IAddNotificationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IAddNotificationMutation, IAddNotificationMutationVariables>(AddNotificationDocument, options);
      }
export type AddNotificationMutationHookResult = ReturnType<typeof useAddNotificationMutation>;
export type AddNotificationMutationResult = Apollo.MutationResult<IAddNotificationMutation>;
export type AddNotificationMutationOptions = Apollo.BaseMutationOptions<IAddNotificationMutation, IAddNotificationMutationVariables>;
export const CloseNotificationDocument = gql`
    mutation CloseNotification($index: Int) {
  closeNotification(index: $index) @client
}
    `;

/**
 * __useCloseNotificationMutation__
 *
 * To run a mutation, you first call `useCloseNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCloseNotificationMutation` 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 [closeNotificationMutation, { data, loading, error }] = useCloseNotificationMutation({
 *   variables: {
 *      index: // value for 'index'
 *   },
 * });
 */
export function useCloseNotificationMutation(baseOptions?: Apollo.MutationHookOptions<ICloseNotificationMutation, ICloseNotificationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ICloseNotificationMutation, ICloseNotificationMutationVariables>(CloseNotificationDocument, options);
      }
export type CloseNotificationMutationHookResult = ReturnType<typeof useCloseNotificationMutation>;
export type CloseNotificationMutationResult = Apollo.MutationResult<ICloseNotificationMutation>;
export type CloseNotificationMutationOptions = Apollo.BaseMutationOptions<ICloseNotificationMutation, ICloseNotificationMutationVariables>;
export const HandlerDocument = gql`
    mutation Handler($arg: ActionRunInput) {
  handler(arg: $arg) @client
}
    `;

/**
 * __useHandlerMutation__
 *
 * To run a mutation, you first call `useHandlerMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHandlerMutation` 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 [handlerMutation, { data, loading, error }] = useHandlerMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export function useHandlerMutation(baseOptions?: Apollo.MutationHookOptions<IHandlerMutation, IHandlerMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHandlerMutation, IHandlerMutationVariables>(HandlerDocument, options);
      }
export type HandlerMutationHookResult = ReturnType<typeof useHandlerMutation>;
export type HandlerMutationResult = Apollo.MutationResult<IHandlerMutation>;
export type HandlerMutationOptions = Apollo.BaseMutationOptions<IHandlerMutation, IHandlerMutationVariables>;
export const OpenEditorFileDocument = gql`
    mutation OpenEditorFile($content: OpenEditor_Input!, $options: EditorOpenOptions_Input) {
  openFile(content: $content, options: $options) @client
}
    `;

/**
 * __useOpenEditorFileMutation__
 *
 * To run a mutation, you first call `useOpenEditorFileMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenEditorFileMutation` 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 [openEditorFileMutation, { data, loading, error }] = useOpenEditorFileMutation({
 *   variables: {
 *      content: // value for 'content'
 *      options: // value for 'options'
 *   },
 * });
 */
export function useOpenEditorFileMutation(baseOptions?: Apollo.MutationHookOptions<IOpenEditorFileMutation, IOpenEditorFileMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenEditorFileMutation, IOpenEditorFileMutationVariables>(OpenEditorFileDocument, options);
      }
export type OpenEditorFileMutationHookResult = ReturnType<typeof useOpenEditorFileMutation>;
export type OpenEditorFileMutationResult = Apollo.MutationResult<IOpenEditorFileMutation>;
export type OpenEditorFileMutationOptions = Apollo.BaseMutationOptions<IOpenEditorFileMutation, IOpenEditorFileMutationVariables>;
export const HideInputModelDocument = gql`
    mutation HideInputModel {
  hideInputModel @client
}
    `;

/**
 * __useHideInputModelMutation__
 *
 * To run a mutation, you first call `useHideInputModelMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHideInputModelMutation` 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 [hideInputModelMutation, { data, loading, error }] = useHideInputModelMutation({
 *   variables: {
 *   },
 * });
 */
export function useHideInputModelMutation(baseOptions?: Apollo.MutationHookOptions<IHideInputModelMutation, IHideInputModelMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHideInputModelMutation, IHideInputModelMutationVariables>(HideInputModelDocument, options);
      }
export type HideInputModelMutationHookResult = ReturnType<typeof useHideInputModelMutation>;
export type HideInputModelMutationResult = Apollo.MutationResult<IHideInputModelMutation>;
export type HideInputModelMutationOptions = Apollo.BaseMutationOptions<IHideInputModelMutation, IHideInputModelMutationVariables>;
export const SetSelectedDocument = gql`
    mutation SetSelected($selectedValue: [PickItem], $inputValue: String) {
  setSelected(selectedValue: $selectedValue, inputValue: $inputValue) @client
}
    `;

/**
 * __useSetSelectedMutation__
 *
 * To run a mutation, you first call `useSetSelectedMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetSelectedMutation` 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 [setSelectedMutation, { data, loading, error }] = useSetSelectedMutation({
 *   variables: {
 *      selectedValue: // value for 'selectedValue'
 *      inputValue: // value for 'inputValue'
 *   },
 * });
 */
export function useSetSelectedMutation(baseOptions?: Apollo.MutationHookOptions<ISetSelectedMutation, ISetSelectedMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISetSelectedMutation, ISetSelectedMutationVariables>(SetSelectedDocument, options);
      }
export type SetSelectedMutationHookResult = ReturnType<typeof useSetSelectedMutation>;
export type SetSelectedMutationResult = Apollo.MutationResult<ISetSelectedMutation>;
export type SetSelectedMutationOptions = Apollo.BaseMutationOptions<ISetSelectedMutation, ISetSelectedMutationVariables>;
export const ShowInputDocument = gql`
    mutation ShowInput($options: InputOptions) {
  showInput(options: $options) @client
}
    `;

/**
 * __useShowInputMutation__
 *
 * To run a mutation, you first call `useShowInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowInputMutation` 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 [showInputMutation, { data, loading, error }] = useShowInputMutation({
 *   variables: {
 *      options: // value for 'options'
 *   },
 * });
 */
export function useShowInputMutation(baseOptions?: Apollo.MutationHookOptions<IShowInputMutation, IShowInputMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IShowInputMutation, IShowInputMutationVariables>(ShowInputDocument, options);
      }
export type ShowInputMutationHookResult = ReturnType<typeof useShowInputMutation>;
export type ShowInputMutationResult = Apollo.MutationResult<IShowInputMutation>;
export type ShowInputMutationOptions = Apollo.BaseMutationOptions<IShowInputMutation, IShowInputMutationVariables>;
export const ShowPickInputDocument = gql`
    mutation ShowPickInput($items: [PickItem], $options: PickInputOptions) {
  showPickInput(items: $items, options: $options) @client
}
    `;

/**
 * __useShowPickInputMutation__
 *
 * To run a mutation, you first call `useShowPickInputMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useShowPickInputMutation` 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 [showPickInputMutation, { data, loading, error }] = useShowPickInputMutation({
 *   variables: {
 *      items: // value for 'items'
 *      options: // value for 'options'
 *   },
 * });
 */
export function useShowPickInputMutation(baseOptions?: Apollo.MutationHookOptions<IShowPickInputMutation, IShowPickInputMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IShowPickInputMutation, IShowPickInputMutationVariables>(ShowPickInputDocument, options);
      }
export type ShowPickInputMutationHookResult = ReturnType<typeof useShowPickInputMutation>;
export type ShowPickInputMutationResult = Apollo.MutationResult<IShowPickInputMutation>;
export type ShowPickInputMutationOptions = Apollo.BaseMutationOptions<IShowPickInputMutation, IShowPickInputMutationVariables>;
export const AddEntryDocument = gql`
    mutation AddEntry($arg: AddEntryInput) {
  addEntry(arg: $arg) @client
}
    `;

/**
 * __useAddEntryMutation__
 *
 * To run a mutation, you first call `useAddEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddEntryMutation` 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 [addEntryMutation, { data, loading, error }] = useAddEntryMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export function useAddEntryMutation(baseOptions?: Apollo.MutationHookOptions<IAddEntryMutation, IAddEntryMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IAddEntryMutation, IAddEntryMutationVariables>(AddEntryDocument, options);
      }
export type AddEntryMutationHookResult = ReturnType<typeof useAddEntryMutation>;
export type AddEntryMutationResult = Apollo.MutationResult<IAddEntryMutation>;
export type AddEntryMutationOptions = Apollo.BaseMutationOptions<IAddEntryMutation, IAddEntryMutationVariables>;
export const RemoveStatusbarEntryDocument = gql`
    mutation RemoveStatusbarEntry($id: ID!) {
  removeStatusbarEntry(id: $id) @client
}
    `;

/**
 * __useRemoveStatusbarEntryMutation__
 *
 * To run a mutation, you first call `useRemoveStatusbarEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveStatusbarEntryMutation` 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 [removeStatusbarEntryMutation, { data, loading, error }] = useRemoveStatusbarEntryMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useRemoveStatusbarEntryMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveStatusbarEntryMutation, IRemoveStatusbarEntryMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRemoveStatusbarEntryMutation, IRemoveStatusbarEntryMutationVariables>(RemoveStatusbarEntryDocument, options);
      }
export type RemoveStatusbarEntryMutationHookResult = ReturnType<typeof useRemoveStatusbarEntryMutation>;
export type RemoveStatusbarEntryMutationResult = Apollo.MutationResult<IRemoveStatusbarEntryMutation>;
export type RemoveStatusbarEntryMutationOptions = Apollo.BaseMutationOptions<IRemoveStatusbarEntryMutation, IRemoveStatusbarEntryMutationVariables>;
export const SetStatusMessageDocument = gql`
    mutation SetStatusMessage($arg: SetStatusMsgInput) {
  setStatusMessage(arg: $arg) @client
}
    `;

/**
 * __useSetStatusMessageMutation__
 *
 * To run a mutation, you first call `useSetStatusMessageMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetStatusMessageMutation` 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 [setStatusMessageMutation, { data, loading, error }] = useSetStatusMessageMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export function useSetStatusMessageMutation(baseOptions?: Apollo.MutationHookOptions<ISetStatusMessageMutation, ISetStatusMessageMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ISetStatusMessageMutation, ISetStatusMessageMutationVariables>(SetStatusMessageDocument, options);
      }
export type SetStatusMessageMutationHookResult = ReturnType<typeof useSetStatusMessageMutation>;
export type SetStatusMessageMutationResult = Apollo.MutationResult<ISetStatusMessageMutation>;
export type SetStatusMessageMutationOptions = Apollo.BaseMutationOptions<ISetStatusMessageMutation, ISetStatusMessageMutationVariables>;
export const UpdateStatusbarEntryDocument = gql`
    mutation UpdateStatusbarEntry($arg: UpdateEntryInput) {
  updateStatusbarEntry(arg: $arg) @client
}
    `;

/**
 * __useUpdateStatusbarEntryMutation__
 *
 * To run a mutation, you first call `useUpdateStatusbarEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateStatusbarEntryMutation` 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 [updateStatusbarEntryMutation, { data, loading, error }] = useUpdateStatusbarEntryMutation({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export function useUpdateStatusbarEntryMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateStatusbarEntryMutation, IUpdateStatusbarEntryMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateStatusbarEntryMutation, IUpdateStatusbarEntryMutationVariables>(UpdateStatusbarEntryDocument, options);
      }
export type UpdateStatusbarEntryMutationHookResult = ReturnType<typeof useUpdateStatusbarEntryMutation>;
export type UpdateStatusbarEntryMutationResult = Apollo.MutationResult<IUpdateStatusbarEntryMutation>;
export type UpdateStatusbarEntryMutationOptions = Apollo.BaseMutationOptions<IUpdateStatusbarEntryMutation, IUpdateStatusbarEntryMutationVariables>;
export const AddFoldersDocument = gql`
    mutation AddFolders($folders: [FolderInput], $index: Int) {
  addFolders(folders: $folders, index: $index) @client
}
    `;

/**
 * __useAddFoldersMutation__
 *
 * To run a mutation, you first call `useAddFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddFoldersMutation` 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 [addFoldersMutation, { data, loading, error }] = useAddFoldersMutation({
 *   variables: {
 *      folders: // value for 'folders'
 *      index: // value for 'index'
 *   },
 * });
 */
export function useAddFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IAddFoldersMutation, IAddFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IAddFoldersMutation, IAddFoldersMutationVariables>(AddFoldersDocument, options);
      }
export type AddFoldersMutationHookResult = ReturnType<typeof useAddFoldersMutation>;
export type AddFoldersMutationResult = Apollo.MutationResult<IAddFoldersMutation>;
export type AddFoldersMutationOptions = Apollo.BaseMutationOptions<IAddFoldersMutation, IAddFoldersMutationVariables>;
export const ChangeWorkspaceDocument = gql`
    mutation ChangeWorkspace($args: ArgsInput) {
  changeWorkspace(args: $args) @client
}
    `;

/**
 * __useChangeWorkspaceMutation__
 *
 * To run a mutation, you first call `useChangeWorkspaceMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeWorkspaceMutation` 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 [changeWorkspaceMutation, { data, loading, error }] = useChangeWorkspaceMutation({
 *   variables: {
 *      args: // value for 'args'
 *   },
 * });
 */
export function useChangeWorkspaceMutation(baseOptions?: Apollo.MutationHookOptions<IChangeWorkspaceMutation, IChangeWorkspaceMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IChangeWorkspaceMutation, IChangeWorkspaceMutationVariables>(ChangeWorkspaceDocument, options);
      }
export type ChangeWorkspaceMutationHookResult = ReturnType<typeof useChangeWorkspaceMutation>;
export type ChangeWorkspaceMutationResult = Apollo.MutationResult<IChangeWorkspaceMutation>;
export type ChangeWorkspaceMutationOptions = Apollo.BaseMutationOptions<IChangeWorkspaceMutation, IChangeWorkspaceMutationVariables>;
export const RemoveFoldersDocument = gql`
    mutation RemoveFolders($folders: [URI]) {
  removeFolders(folders: $folders) @client
}
    `;

/**
 * __useRemoveFoldersMutation__
 *
 * To run a mutation, you first call `useRemoveFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveFoldersMutation` 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 [removeFoldersMutation, { data, loading, error }] = useRemoveFoldersMutation({
 *   variables: {
 *      folders: // value for 'folders'
 *   },
 * });
 */
export function useRemoveFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveFoldersMutation, IRemoveFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRemoveFoldersMutation, IRemoveFoldersMutationVariables>(RemoveFoldersDocument, options);
      }
export type RemoveFoldersMutationHookResult = ReturnType<typeof useRemoveFoldersMutation>;
export type RemoveFoldersMutationResult = Apollo.MutationResult<IRemoveFoldersMutation>;
export type RemoveFoldersMutationOptions = Apollo.BaseMutationOptions<IRemoveFoldersMutation, IRemoveFoldersMutationVariables>;
export const UpdateFoldersDocument = gql`
    mutation UpdateFolders($foldersToAdd: [FolderInput], $foldersToRemove: [URI], $index: Int) {
  updateFolders(
    foldersToAdd: $foldersToAdd
    foldersToRemove: $foldersToRemove
    index: $index
  ) @client
}
    `;

/**
 * __useUpdateFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateFoldersMutation` 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 [updateFoldersMutation, { data, loading, error }] = useUpdateFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      foldersToRemove: // value for 'foldersToRemove'
 *      index: // value for 'index'
 *   },
 * });
 */
export function useUpdateFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateFoldersMutation, IUpdateFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateFoldersMutation, IUpdateFoldersMutationVariables>(UpdateFoldersDocument, options);
      }
export type UpdateFoldersMutationHookResult = ReturnType<typeof useUpdateFoldersMutation>;
export type UpdateFoldersMutationResult = Apollo.MutationResult<IUpdateFoldersMutation>;
export type UpdateFoldersMutationOptions = Apollo.BaseMutationOptions<IUpdateFoldersMutation, IUpdateFoldersMutationVariables>;
export const FinalConfiguration_WsDocument = gql`
    query FinalConfiguration_WS {
  viewerSettings {
    finalConfiguration {
      ...FinalConfiguration
    }
  }
}
    ${FinalConfigurationFragmentDoc}`;

/**
 * __useFinalConfiguration_WsQuery__
 *
 * To run a query within a React component, call `useFinalConfiguration_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFinalConfiguration_WsQuery` 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 } = useFinalConfiguration_WsQuery({
 *   variables: {
 *   },
 * });
 */
export function useFinalConfiguration_WsQuery(baseOptions?: Apollo.QueryHookOptions<IFinalConfiguration_WsQuery, IFinalConfiguration_WsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IFinalConfiguration_WsQuery, IFinalConfiguration_WsQueryVariables>(FinalConfiguration_WsDocument, options);
      }
export function useFinalConfiguration_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFinalConfiguration_WsQuery, IFinalConfiguration_WsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IFinalConfiguration_WsQuery, IFinalConfiguration_WsQueryVariables>(FinalConfiguration_WsDocument, options);
        }
export type FinalConfiguration_WsQueryHookResult = ReturnType<typeof useFinalConfiguration_WsQuery>;
export type FinalConfiguration_WsLazyQueryHookResult = ReturnType<typeof useFinalConfiguration_WsLazyQuery>;
export type FinalConfiguration_WsQueryResult = Apollo.QueryResult<IFinalConfiguration_WsQuery, IFinalConfiguration_WsQueryVariables>;
export const GetContextDocument = gql`
    query GetContext {
  getContextData @client {
    ...AllContext
  }
}
    ${AllContextFragmentDoc}`;

/**
 * __useGetContextQuery__
 *
 * To run a query within a React component, call `useGetContextQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetContextQuery` 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 } = useGetContextQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetContextQuery(baseOptions?: Apollo.QueryHookOptions<IGetContextQuery, IGetContextQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetContextQuery, IGetContextQueryVariables>(GetContextDocument, options);
      }
export function useGetContextLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetContextQuery, IGetContextQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetContextQuery, IGetContextQueryVariables>(GetContextDocument, options);
        }
export type GetContextQueryHookResult = ReturnType<typeof useGetContextQuery>;
export type GetContextLazyQueryHookResult = ReturnType<typeof useGetContextLazyQuery>;
export type GetContextQueryResult = Apollo.QueryResult<IGetContextQuery, IGetContextQueryVariables>;
export const ContextMenuDocument = gql`
    query ContextMenu {
  contextMenu @client {
    id
    isShow
    anchor {
      x
      y
      height
      width
    }
    menuItems {
      id
      label
      enabled
      run {
        type
        document
        variables
      }
    }
  }
}
    `;

/**
 * __useContextMenuQuery__
 *
 * To run a query within a React component, call `useContextMenuQuery` and pass it any options that fit your needs.
 * When your component renders, `useContextMenuQuery` 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 } = useContextMenuQuery({
 *   variables: {
 *   },
 * });
 */
export function useContextMenuQuery(baseOptions?: Apollo.QueryHookOptions<IContextMenuQuery, IContextMenuQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IContextMenuQuery, IContextMenuQueryVariables>(ContextMenuDocument, options);
      }
export function useContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IContextMenuQuery, IContextMenuQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IContextMenuQuery, IContextMenuQueryVariables>(ContextMenuDocument, options);
        }
export type ContextMenuQueryHookResult = ReturnType<typeof useContextMenuQuery>;
export type ContextMenuLazyQueryHookResult = ReturnType<typeof useContextMenuLazyQuery>;
export type ContextMenuQueryResult = Apollo.QueryResult<IContextMenuQuery, IContextMenuQueryVariables>;
export const DialogDocument = gql`
    query Dialog {
  dialog @client {
    dialogType
    detail {
      inputName
      inputType {
        type
        options
      }
      label
      placeholder
      defaultValue
      required
    }
    primaryButton {
      label
      run {
        type
        document
        variables
      }
    }
    secondaryButton
    checkbox {
      label
      checked
    }
  }
}
    `;

/**
 * __useDialogQuery__
 *
 * To run a query within a React component, call `useDialogQuery` and pass it any options that fit your needs.
 * When your component renders, `useDialogQuery` 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 } = useDialogQuery({
 *   variables: {
 *   },
 * });
 */
export function useDialogQuery(baseOptions?: Apollo.QueryHookOptions<IDialogQuery, IDialogQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IDialogQuery, IDialogQueryVariables>(DialogDocument, options);
      }
export function useDialogLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IDialogQuery, IDialogQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IDialogQuery, IDialogQueryVariables>(DialogDocument, options);
        }
export type DialogQueryHookResult = ReturnType<typeof useDialogQuery>;
export type DialogLazyQueryHookResult = ReturnType<typeof useDialogLazyQuery>;
export type DialogQueryResult = Apollo.QueryResult<IDialogQuery, IDialogQueryVariables>;
export const ShowDialogDocument = gql`
    query showDialog($dialog: DialogInput) {
  showDialog(dialog: $dialog) @client {
    confirmed
    checkboxChecked
  }
}
    `;

/**
 * __useShowDialogQuery__
 *
 * To run a query within a React component, call `useShowDialogQuery` and pass it any options that fit your needs.
 * When your component renders, `useShowDialogQuery` 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 } = useShowDialogQuery({
 *   variables: {
 *      dialog: // value for 'dialog'
 *   },
 * });
 */
export function useShowDialogQuery(baseOptions?: Apollo.QueryHookOptions<IShowDialogQuery, IShowDialogQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IShowDialogQuery, IShowDialogQueryVariables>(ShowDialogDocument, options);
      }
export function useShowDialogLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IShowDialogQuery, IShowDialogQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IShowDialogQuery, IShowDialogQueryVariables>(ShowDialogDocument, options);
        }
export type ShowDialogQueryHookResult = ReturnType<typeof useShowDialogQuery>;
export type ShowDialogLazyQueryHookResult = ReturnType<typeof useShowDialogLazyQuery>;
export type ShowDialogQueryResult = Apollo.QueryResult<IShowDialogQuery, IShowDialogQueryVariables>;
export const GoToLineQuickAccessDocument = gql`
    query GoToLineQuickAccess {
  gotoLineQuickAccess @client {
    range {
      startLine
      startColumn
      endLine
      endColumn
    }
    highlight
    focus
  }
}
    `;

/**
 * __useGoToLineQuickAccessQuery__
 *
 * To run a query within a React component, call `useGoToLineQuickAccessQuery` and pass it any options that fit your needs.
 * When your component renders, `useGoToLineQuickAccessQuery` 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 } = useGoToLineQuickAccessQuery({
 *   variables: {
 *   },
 * });
 */
export function useGoToLineQuickAccessQuery(baseOptions?: Apollo.QueryHookOptions<IGoToLineQuickAccessQuery, IGoToLineQuickAccessQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGoToLineQuickAccessQuery, IGoToLineQuickAccessQueryVariables>(GoToLineQuickAccessDocument, options);
      }
export function useGoToLineQuickAccessLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGoToLineQuickAccessQuery, IGoToLineQuickAccessQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGoToLineQuickAccessQuery, IGoToLineQuickAccessQueryVariables>(GoToLineQuickAccessDocument, options);
        }
export type GoToLineQuickAccessQueryHookResult = ReturnType<typeof useGoToLineQuickAccessQuery>;
export type GoToLineQuickAccessLazyQueryHookResult = ReturnType<typeof useGoToLineQuickAccessLazyQuery>;
export type GoToLineQuickAccessQueryResult = Apollo.QueryResult<IGoToLineQuickAccessQuery, IGoToLineQuickAccessQueryVariables>;
export const GetKeybindingsDocument = gql`
    query GetKeybindings {
  getKeybindings @client {
    items {
      command
      key
      when
      source
    }
  }
}
    `;

/**
 * __useGetKeybindingsQuery__
 *
 * To run a query within a React component, call `useGetKeybindingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetKeybindingsQuery` 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 } = useGetKeybindingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetKeybindingsQuery(baseOptions?: Apollo.QueryHookOptions<IGetKeybindingsQuery, IGetKeybindingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetKeybindingsQuery, IGetKeybindingsQueryVariables>(GetKeybindingsDocument, options);
      }
export function useGetKeybindingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetKeybindingsQuery, IGetKeybindingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetKeybindingsQuery, IGetKeybindingsQueryVariables>(GetKeybindingsDocument, options);
        }
export type GetKeybindingsQueryHookResult = ReturnType<typeof useGetKeybindingsQuery>;
export type GetKeybindingsLazyQueryHookResult = ReturnType<typeof useGetKeybindingsLazyQuery>;
export type GetKeybindingsQueryResult = Apollo.QueryResult<IGetKeybindingsQuery, IGetKeybindingsQueryVariables>;
export const KeybindingContextMenuDocument = gql`
    query KeybindingContextMenu {
  keybindingContextMenu @client {
    editItem {
      command
      key
      when
      isDefault
    }
    selectedItemIndex
    editWhenIndex
    newWhen
    isOpenDialog
    search
  }
}
    `;

/**
 * __useKeybindingContextMenuQuery__
 *
 * To run a query within a React component, call `useKeybindingContextMenuQuery` and pass it any options that fit your needs.
 * When your component renders, `useKeybindingContextMenuQuery` 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 } = useKeybindingContextMenuQuery({
 *   variables: {
 *   },
 * });
 */
export function useKeybindingContextMenuQuery(baseOptions?: Apollo.QueryHookOptions<IKeybindingContextMenuQuery, IKeybindingContextMenuQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IKeybindingContextMenuQuery, IKeybindingContextMenuQueryVariables>(KeybindingContextMenuDocument, options);
      }
export function useKeybindingContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IKeybindingContextMenuQuery, IKeybindingContextMenuQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IKeybindingContextMenuQuery, IKeybindingContextMenuQueryVariables>(KeybindingContextMenuDocument, options);
        }
export type KeybindingContextMenuQueryHookResult = ReturnType<typeof useKeybindingContextMenuQuery>;
export type KeybindingContextMenuLazyQueryHookResult = ReturnType<typeof useKeybindingContextMenuLazyQuery>;
export type KeybindingContextMenuQueryResult = Apollo.QueryResult<IKeybindingContextMenuQuery, IKeybindingContextMenuQueryVariables>;
export const KeybindingsDocument = gql`
    query Keybindings {
  keybindings @client {
    items {
      command
      key
      when
      source
    }
  }
}
    `;

/**
 * __useKeybindingsQuery__
 *
 * To run a query within a React component, call `useKeybindingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useKeybindingsQuery` 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 } = useKeybindingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useKeybindingsQuery(baseOptions?: Apollo.QueryHookOptions<IKeybindingsQuery, IKeybindingsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IKeybindingsQuery, IKeybindingsQueryVariables>(KeybindingsDocument, options);
      }
export function useKeybindingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IKeybindingsQuery, IKeybindingsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IKeybindingsQuery, IKeybindingsQueryVariables>(KeybindingsDocument, options);
        }
export type KeybindingsQueryHookResult = ReturnType<typeof useKeybindingsQuery>;
export type KeybindingsLazyQueryHookResult = ReturnType<typeof useKeybindingsLazyQuery>;
export type KeybindingsQueryResult = Apollo.QueryResult<IKeybindingsQuery, IKeybindingsQueryVariables>;
export const NotificationsDocument = gql`
    query Notifications {
  notifications @client {
    notifications {
      index
      severity
      message
      actions {
        primary {
          id
          label
          tooltip
          class
          enabled
          checked
          radio
          run {
            type
            document
            variables
          }
        }
        secondary {
          id
          label
          tooltip
          class
          enabled
          checked
          radio
          run {
            type
            document
            variables
          }
        }
      }
      sticky
    }
  }
}
    `;

/**
 * __useNotificationsQuery__
 *
 * To run a query within a React component, call `useNotificationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useNotificationsQuery` 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 } = useNotificationsQuery({
 *   variables: {
 *   },
 * });
 */
export function useNotificationsQuery(baseOptions?: Apollo.QueryHookOptions<INotificationsQuery, INotificationsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<INotificationsQuery, INotificationsQueryVariables>(NotificationsDocument, options);
      }
export function useNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<INotificationsQuery, INotificationsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<INotificationsQuery, INotificationsQueryVariables>(NotificationsDocument, options);
        }
export type NotificationsQueryHookResult = ReturnType<typeof useNotificationsQuery>;
export type NotificationsLazyQueryHookResult = ReturnType<typeof useNotificationsLazyQuery>;
export type NotificationsQueryResult = Apollo.QueryResult<INotificationsQuery, INotificationsQueryVariables>;
export const ShowNotificationDocument = gql`
    query showNotification($notification: NotificationInput) {
  showNotification(notification: $notification) @client
}
    `;

/**
 * __useShowNotificationQuery__
 *
 * To run a query within a React component, call `useShowNotificationQuery` and pass it any options that fit your needs.
 * When your component renders, `useShowNotificationQuery` 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 } = useShowNotificationQuery({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export function useShowNotificationQuery(baseOptions?: Apollo.QueryHookOptions<IShowNotificationQuery, IShowNotificationQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IShowNotificationQuery, IShowNotificationQueryVariables>(ShowNotificationDocument, options);
      }
export function useShowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IShowNotificationQuery, IShowNotificationQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IShowNotificationQuery, IShowNotificationQueryVariables>(ShowNotificationDocument, options);
        }
export type ShowNotificationQueryHookResult = ReturnType<typeof useShowNotificationQuery>;
export type ShowNotificationLazyQueryHookResult = ReturnType<typeof useShowNotificationLazyQuery>;
export type ShowNotificationQueryResult = Apollo.QueryResult<IShowNotificationQuery, IShowNotificationQueryVariables>;
export const GetSelectedValueDocument = gql`
    query GetSelectedValue {
  quickInputModel @client {
    title
    selectedValue {
      ...pickItem
    }
    inputValue
  }
}
    ${PickItemFragmentDoc}`;

/**
 * __useGetSelectedValueQuery__
 *
 * To run a query within a React component, call `useGetSelectedValueQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSelectedValueQuery` 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 } = useGetSelectedValueQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetSelectedValueQuery(baseOptions?: Apollo.QueryHookOptions<IGetSelectedValueQuery, IGetSelectedValueQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetSelectedValueQuery, IGetSelectedValueQueryVariables>(GetSelectedValueDocument, options);
      }
export function useGetSelectedValueLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetSelectedValueQuery, IGetSelectedValueQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetSelectedValueQuery, IGetSelectedValueQueryVariables>(GetSelectedValueDocument, options);
        }
export type GetSelectedValueQueryHookResult = ReturnType<typeof useGetSelectedValueQuery>;
export type GetSelectedValueLazyQueryHookResult = ReturnType<typeof useGetSelectedValueLazyQuery>;
export type GetSelectedValueQueryResult = Apollo.QueryResult<IGetSelectedValueQuery, IGetSelectedValueQueryVariables>;
export const QuickInputModelDocument = gql`
    query QuickInputModel {
  quickInputModel @client {
    show
    input {
      title
      description
      enabled
      ignoreFocusOut
      value
      placeholder
      prompt
      validationMessage
    }
    quickPick {
      placeholder
      canSelectMany
      autoFocusOnList
      items {
        ...pickItem
      }
      activeItem {
        ...pickItem
      }
      selectedItems {
        ...pickItem
      }
    }
  }
}
    ${PickItemFragmentDoc}`;

/**
 * __useQuickInputModelQuery__
 *
 * To run a query within a React component, call `useQuickInputModelQuery` and pass it any options that fit your needs.
 * When your component renders, `useQuickInputModelQuery` 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 } = useQuickInputModelQuery({
 *   variables: {
 *   },
 * });
 */
export function useQuickInputModelQuery(baseOptions?: Apollo.QueryHookOptions<IQuickInputModelQuery, IQuickInputModelQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IQuickInputModelQuery, IQuickInputModelQueryVariables>(QuickInputModelDocument, options);
      }
export function useQuickInputModelLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IQuickInputModelQuery, IQuickInputModelQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IQuickInputModelQuery, IQuickInputModelQueryVariables>(QuickInputModelDocument, options);
        }
export type QuickInputModelQueryHookResult = ReturnType<typeof useQuickInputModelQuery>;
export type QuickInputModelLazyQueryHookResult = ReturnType<typeof useQuickInputModelLazyQuery>;
export type QuickInputModelQueryResult = Apollo.QueryResult<IQuickInputModelQuery, IQuickInputModelQueryVariables>;
export const StatusbarDocument = gql`
    query Statusbar {
  statusbar @client {
    items {
      ... on Terminal {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on SelectionStatus {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on Indentation {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on EncodingStatus {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on EndOfLineSequence {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on LanguageMode {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on SyncStatus {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
      ... on BranchStatus {
        id
        name
        alignment
        priority
        typeId
        entry {
          showTabsButtons
          showIcons
          showStatusbar
          text
          ariaLabel
          tooltip
          color
          backgroundColor
          command
          arguments
          showBeak
        }
      }
    }
  }
}
    `;

/**
 * __useStatusbarQuery__
 *
 * To run a query within a React component, call `useStatusbarQuery` and pass it any options that fit your needs.
 * When your component renders, `useStatusbarQuery` 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 } = useStatusbarQuery({
 *   variables: {
 *   },
 * });
 */
export function useStatusbarQuery(baseOptions?: Apollo.QueryHookOptions<IStatusbarQuery, IStatusbarQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IStatusbarQuery, IStatusbarQueryVariables>(StatusbarDocument, options);
      }
export function useStatusbarLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IStatusbarQuery, IStatusbarQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IStatusbarQuery, IStatusbarQueryVariables>(StatusbarDocument, options);
        }
export type StatusbarQueryHookResult = ReturnType<typeof useStatusbarQuery>;
export type StatusbarLazyQueryHookResult = ReturnType<typeof useStatusbarLazyQuery>;
export type StatusbarQueryResult = Apollo.QueryResult<IStatusbarQuery, IStatusbarQueryVariables>;
export const StatusbarItemDocument = gql`
    query StatusbarItem($id: String) {
  statusbarItem(id: $id) @client {
    ... on Terminal {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on SelectionStatus {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on Indentation {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on EncodingStatus {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on EndOfLineSequence {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on LanguageMode {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on SyncStatus {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
    ... on BranchStatus {
      id
      name
      alignment
      priority
      typeId
      entry {
        showTabsButtons
        showIcons
        showStatusbar
        text
        ariaLabel
        tooltip
        color
        backgroundColor
        command
        arguments
        showBeak
      }
    }
  }
}
    `;

/**
 * __useStatusbarItemQuery__
 *
 * To run a query within a React component, call `useStatusbarItemQuery` and pass it any options that fit your needs.
 * When your component renders, `useStatusbarItemQuery` 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 } = useStatusbarItemQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useStatusbarItemQuery(baseOptions?: Apollo.QueryHookOptions<IStatusbarItemQuery, IStatusbarItemQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IStatusbarItemQuery, IStatusbarItemQueryVariables>(StatusbarItemDocument, options);
      }
export function useStatusbarItemLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IStatusbarItemQuery, IStatusbarItemQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IStatusbarItemQuery, IStatusbarItemQueryVariables>(StatusbarItemDocument, options);
        }
export type StatusbarItemQueryHookResult = ReturnType<typeof useStatusbarItemQuery>;
export type StatusbarItemLazyQueryHookResult = ReturnType<typeof useStatusbarItemLazyQuery>;
export type StatusbarItemQueryResult = Apollo.QueryResult<IStatusbarItemQuery, IStatusbarItemQueryVariables>;
export const GetViewsDocument = gql`
    query GetViews($containerId: String!) {
  getViews(containerId: $containerId) @client {
    id
    name
  }
}
    `;

/**
 * __useGetViewsQuery__
 *
 * To run a query within a React component, call `useGetViewsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetViewsQuery` 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 } = useGetViewsQuery({
 *   variables: {
 *      containerId: // value for 'containerId'
 *   },
 * });
 */
export function useGetViewsQuery(baseOptions: Apollo.QueryHookOptions<IGetViewsQuery, IGetViewsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetViewsQuery, IGetViewsQueryVariables>(GetViewsDocument, options);
      }
export function useGetViewsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetViewsQuery, IGetViewsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetViewsQuery, IGetViewsQueryVariables>(GetViewsDocument, options);
        }
export type GetViewsQueryHookResult = ReturnType<typeof useGetViewsQuery>;
export type GetViewsLazyQueryHookResult = ReturnType<typeof useGetViewsLazyQuery>;
export type GetViewsQueryResult = Apollo.QueryResult<IGetViewsQuery, IGetViewsQueryVariables>;
export const GetWorkspaceDocument = gql`
    query GetWorkspace {
  getWorkspace {
    id
    folders {
      uri
      name
      index
    }
    name
    configuration
  }
}
    `;

/**
 * __useGetWorkspaceQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceQuery` 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 } = useGetWorkspaceQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetWorkspaceQuery(baseOptions?: Apollo.QueryHookOptions<IGetWorkspaceQuery, IGetWorkspaceQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetWorkspaceQuery, IGetWorkspaceQueryVariables>(GetWorkspaceDocument, options);
      }
export function useGetWorkspaceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetWorkspaceQuery, IGetWorkspaceQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetWorkspaceQuery, IGetWorkspaceQueryVariables>(GetWorkspaceDocument, options);
        }
export type GetWorkspaceQueryHookResult = ReturnType<typeof useGetWorkspaceQuery>;
export type GetWorkspaceLazyQueryHookResult = ReturnType<typeof useGetWorkspaceLazyQuery>;
export type GetWorkspaceQueryResult = Apollo.QueryResult<IGetWorkspaceQuery, IGetWorkspaceQueryVariables>;
export const NotifyErrorDocument = gql`
    mutation NotifyError($message: [NotificationMessageInput]) {
  notifyError(message: $message)
}
    `;

/**
 * __useNotifyErrorMutation__
 *
 * To run a mutation, you first call `useNotifyErrorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyErrorMutation` 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 [notifyErrorMutation, { data, loading, error }] = useNotifyErrorMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export function useNotifyErrorMutation(baseOptions?: Apollo.MutationHookOptions<INotifyErrorMutation, INotifyErrorMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<INotifyErrorMutation, INotifyErrorMutationVariables>(NotifyErrorDocument, options);
      }
export type NotifyErrorMutationHookResult = ReturnType<typeof useNotifyErrorMutation>;
export type NotifyErrorMutationResult = Apollo.MutationResult<INotifyErrorMutation>;
export type NotifyErrorMutationOptions = Apollo.BaseMutationOptions<INotifyErrorMutation, INotifyErrorMutationVariables>;
export const NotifyInfoDocument = gql`
    mutation NotifyInfo($message: [NotificationMessageInput]) {
  notifyInfo(message: $message)
}
    `;

/**
 * __useNotifyInfoMutation__
 *
 * To run a mutation, you first call `useNotifyInfoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyInfoMutation` 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 [notifyInfoMutation, { data, loading, error }] = useNotifyInfoMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export function useNotifyInfoMutation(baseOptions?: Apollo.MutationHookOptions<INotifyInfoMutation, INotifyInfoMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<INotifyInfoMutation, INotifyInfoMutationVariables>(NotifyInfoDocument, options);
      }
export type NotifyInfoMutationHookResult = ReturnType<typeof useNotifyInfoMutation>;
export type NotifyInfoMutationResult = Apollo.MutationResult<INotifyInfoMutation>;
export type NotifyInfoMutationOptions = Apollo.BaseMutationOptions<INotifyInfoMutation, INotifyInfoMutationVariables>;
export const NotifyPromptDocument = gql`
    mutation NotifyPrompt($severity: NotificationSeverity, $message: String, $choices: [PromptChoiceInput], $options: PromptOptionsInput) {
  notifyPrompt(
    severity: $severity
    message: $message
    choices: $choices
    options: $options
  )
}
    `;

/**
 * __useNotifyPromptMutation__
 *
 * To run a mutation, you first call `useNotifyPromptMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyPromptMutation` 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 [notifyPromptMutation, { data, loading, error }] = useNotifyPromptMutation({
 *   variables: {
 *      severity: // value for 'severity'
 *      message: // value for 'message'
 *      choices: // value for 'choices'
 *      options: // value for 'options'
 *   },
 * });
 */
export function useNotifyPromptMutation(baseOptions?: Apollo.MutationHookOptions<INotifyPromptMutation, INotifyPromptMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<INotifyPromptMutation, INotifyPromptMutationVariables>(NotifyPromptDocument, options);
      }
export type NotifyPromptMutationHookResult = ReturnType<typeof useNotifyPromptMutation>;
export type NotifyPromptMutationResult = Apollo.MutationResult<INotifyPromptMutation>;
export type NotifyPromptMutationOptions = Apollo.BaseMutationOptions<INotifyPromptMutation, INotifyPromptMutationVariables>;
export const NotifyWarnDocument = gql`
    mutation NotifyWarn($message: [NotificationMessageInput]) {
  notifyWarn(message: $message)
}
    `;

/**
 * __useNotifyWarnMutation__
 *
 * To run a mutation, you first call `useNotifyWarnMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyWarnMutation` 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 [notifyWarnMutation, { data, loading, error }] = useNotifyWarnMutation({
 *   variables: {
 *      message: // value for 'message'
 *   },
 * });
 */
export function useNotifyWarnMutation(baseOptions?: Apollo.MutationHookOptions<INotifyWarnMutation, INotifyWarnMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<INotifyWarnMutation, INotifyWarnMutationVariables>(NotifyWarnDocument, options);
      }
export type NotifyWarnMutationHookResult = ReturnType<typeof useNotifyWarnMutation>;
export type NotifyWarnMutationResult = Apollo.MutationResult<INotifyWarnMutation>;
export type NotifyWarnMutationOptions = Apollo.BaseMutationOptions<INotifyWarnMutation, INotifyWarnMutationVariables>;
export const NotifyDocument = gql`
    mutation Notify($notification: NotificationInput) {
  notify(notification: $notification)
}
    `;

/**
 * __useNotifyMutation__
 *
 * To run a mutation, you first call `useNotifyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useNotifyMutation` 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 [notifyMutation, { data, loading, error }] = useNotifyMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export function useNotifyMutation(baseOptions?: Apollo.MutationHookOptions<INotifyMutation, INotifyMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<INotifyMutation, INotifyMutationVariables>(NotifyDocument, options);
      }
export type NotifyMutationHookResult = ReturnType<typeof useNotifyMutation>;
export type NotifyMutationResult = Apollo.MutationResult<INotifyMutation>;
export type NotifyMutationOptions = Apollo.BaseMutationOptions<INotifyMutation, INotifyMutationVariables>;
export const UpdateWorkspaceContextAddFoldersDocument = gql`
    mutation UpdateWorkspaceContextAddFolders($foldersToAdd: [FoldersToAdd_Input], $index: Int) {
  updateWorkspaceContextAddFolders(foldersToAdd: $foldersToAdd, index: $index) {
    uri
    name
    index
  }
}
    `;

/**
 * __useUpdateWorkspaceContextAddFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextAddFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextAddFoldersMutation` 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 [updateWorkspaceContextAddFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextAddFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      index: // value for 'index'
 *   },
 * });
 */
export function useUpdateWorkspaceContextAddFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateWorkspaceContextAddFoldersMutation, IUpdateWorkspaceContextAddFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateWorkspaceContextAddFoldersMutation, IUpdateWorkspaceContextAddFoldersMutationVariables>(UpdateWorkspaceContextAddFoldersDocument, options);
      }
export type UpdateWorkspaceContextAddFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextAddFoldersMutation>;
export type UpdateWorkspaceContextAddFoldersMutationResult = Apollo.MutationResult<IUpdateWorkspaceContextAddFoldersMutation>;
export type UpdateWorkspaceContextAddFoldersMutationOptions = Apollo.BaseMutationOptions<IUpdateWorkspaceContextAddFoldersMutation, IUpdateWorkspaceContextAddFoldersMutationVariables>;
export const UpdateWorkspaceContextRemoveFoldersDocument = gql`
    mutation UpdateWorkspaceContextRemoveFolders($foldersToRemove: [URI]) {
  updateWorkspaceContextRemoveFolders(foldersToRemove: $foldersToRemove) {
    uri
    name
    index
  }
}
    `;

/**
 * __useUpdateWorkspaceContextRemoveFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextRemoveFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextRemoveFoldersMutation` 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 [updateWorkspaceContextRemoveFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextRemoveFoldersMutation({
 *   variables: {
 *      foldersToRemove: // value for 'foldersToRemove'
 *   },
 * });
 */
export function useUpdateWorkspaceContextRemoveFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateWorkspaceContextRemoveFoldersMutation, IUpdateWorkspaceContextRemoveFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateWorkspaceContextRemoveFoldersMutation, IUpdateWorkspaceContextRemoveFoldersMutationVariables>(UpdateWorkspaceContextRemoveFoldersDocument, options);
      }
export type UpdateWorkspaceContextRemoveFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextRemoveFoldersMutation>;
export type UpdateWorkspaceContextRemoveFoldersMutationResult = Apollo.MutationResult<IUpdateWorkspaceContextRemoveFoldersMutation>;
export type UpdateWorkspaceContextRemoveFoldersMutationOptions = Apollo.BaseMutationOptions<IUpdateWorkspaceContextRemoveFoldersMutation, IUpdateWorkspaceContextRemoveFoldersMutationVariables>;
export const UpdateWorkspaceContextUpdateFoldersDocument = gql`
    mutation UpdateWorkspaceContextUpdateFolders($foldersToAdd: [FoldersToAdd_Input], $foldersToRemove: [URI], $index: Int) {
  updateWorkspaceContextUpdateFolders(
    foldersToAdd: $foldersToAdd
    foldersToRemove: $foldersToRemove
    index: $index
  ) {
    uri
    name
    index
  }
}
    `;

/**
 * __useUpdateWorkspaceContextUpdateFoldersMutation__
 *
 * To run a mutation, you first call `useUpdateWorkspaceContextUpdateFoldersMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkspaceContextUpdateFoldersMutation` 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 [updateWorkspaceContextUpdateFoldersMutation, { data, loading, error }] = useUpdateWorkspaceContextUpdateFoldersMutation({
 *   variables: {
 *      foldersToAdd: // value for 'foldersToAdd'
 *      foldersToRemove: // value for 'foldersToRemove'
 *      index: // value for 'index'
 *   },
 * });
 */
export function useUpdateWorkspaceContextUpdateFoldersMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateWorkspaceContextUpdateFoldersMutation, IUpdateWorkspaceContextUpdateFoldersMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateWorkspaceContextUpdateFoldersMutation, IUpdateWorkspaceContextUpdateFoldersMutationVariables>(UpdateWorkspaceContextUpdateFoldersDocument, options);
      }
export type UpdateWorkspaceContextUpdateFoldersMutationHookResult = ReturnType<typeof useUpdateWorkspaceContextUpdateFoldersMutation>;
export type UpdateWorkspaceContextUpdateFoldersMutationResult = Apollo.MutationResult<IUpdateWorkspaceContextUpdateFoldersMutation>;
export type UpdateWorkspaceContextUpdateFoldersMutationOptions = Apollo.BaseMutationOptions<IUpdateWorkspaceContextUpdateFoldersMutation, IUpdateWorkspaceContextUpdateFoldersMutationVariables>;
export const GetConfiguration_WsDocument = gql`
    query GetConfiguration_WS {
  getConfigurationData {
    ...GetConfigurationData
  }
}
    ${GetConfigurationDataFragmentDoc}`;

/**
 * __useGetConfiguration_WsQuery__
 *
 * To run a query within a React component, call `useGetConfiguration_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetConfiguration_WsQuery` 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 } = useGetConfiguration_WsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetConfiguration_WsQuery(baseOptions?: Apollo.QueryHookOptions<IGetConfiguration_WsQuery, IGetConfiguration_WsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetConfiguration_WsQuery, IGetConfiguration_WsQueryVariables>(GetConfiguration_WsDocument, options);
      }
export function useGetConfiguration_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetConfiguration_WsQuery, IGetConfiguration_WsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetConfiguration_WsQuery, IGetConfiguration_WsQueryVariables>(GetConfiguration_WsDocument, options);
        }
export type GetConfiguration_WsQueryHookResult = ReturnType<typeof useGetConfiguration_WsQuery>;
export type GetConfiguration_WsLazyQueryHookResult = ReturnType<typeof useGetConfiguration_WsLazyQuery>;
export type GetConfiguration_WsQueryResult = Apollo.QueryResult<IGetConfiguration_WsQuery, IGetConfiguration_WsQueryVariables>;
export const GetEnvironment_WsDocument = gql`
    query GetEnvironment_WS {
  getEnvironment {
    execPath
    cliPath
    appRoot
    userHome
    userDataPath
    appNameLong
    appQuality
    appSettingsHome
    appSettingsPath
    appKeybindingsPath
    settingsSearchBuildId
    settingsSearchUrl
    globalStorageHome
    workspaceStorageHome
    backupHome
    backupWorkspacesPath
    workspacesHome
    workspaceSettingsPath
    isExtensionDevelopment
    disableExtensions
    builtinExtensionsPath
    extensionsPath
    extensionDevelopmentLocationURI
    extensionTestsPath
    debugExtensionHost {
      port
      break
      debugId
    }
    logExtensionHostCommunication
    isBuilt
    wait
    status
    performance
    logsPath
    log
    verbose
    logLevel
    skipGettingStarted
    skipReleaseNotes
    skipAddToRecentlyOpened
    nodeCachedDataDir
    installSourcePath
    disableUpdates
    disableCrashReporter
    driverHandle
    driverVerbose
  }
}
    `;

/**
 * __useGetEnvironment_WsQuery__
 *
 * To run a query within a React component, call `useGetEnvironment_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetEnvironment_WsQuery` 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 } = useGetEnvironment_WsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetEnvironment_WsQuery(baseOptions?: Apollo.QueryHookOptions<IGetEnvironment_WsQuery, IGetEnvironment_WsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetEnvironment_WsQuery, IGetEnvironment_WsQueryVariables>(GetEnvironment_WsDocument, options);
      }
export function useGetEnvironment_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetEnvironment_WsQuery, IGetEnvironment_WsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetEnvironment_WsQuery, IGetEnvironment_WsQueryVariables>(GetEnvironment_WsDocument, options);
        }
export type GetEnvironment_WsQueryHookResult = ReturnType<typeof useGetEnvironment_WsQuery>;
export type GetEnvironment_WsLazyQueryHookResult = ReturnType<typeof useGetEnvironment_WsLazyQuery>;
export type GetEnvironment_WsQueryResult = Apollo.QueryResult<IGetEnvironment_WsQuery, IGetEnvironment_WsQueryVariables>;
export const GetWorkspace_WsDocument = gql`
    query GetWorkspace_WS {
  getWorkspace {
    id
    folders {
      ...WorkspaceFolder
    }
    name
    configuration
  }
}
    ${WorkspaceFolderFragmentDoc}`;

/**
 * __useGetWorkspace_WsQuery__
 *
 * To run a query within a React component, call `useGetWorkspace_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspace_WsQuery` 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 } = useGetWorkspace_WsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetWorkspace_WsQuery(baseOptions?: Apollo.QueryHookOptions<IGetWorkspace_WsQuery, IGetWorkspace_WsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetWorkspace_WsQuery, IGetWorkspace_WsQueryVariables>(GetWorkspace_WsDocument, options);
      }
export function useGetWorkspace_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetWorkspace_WsQuery, IGetWorkspace_WsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetWorkspace_WsQuery, IGetWorkspace_WsQueryVariables>(GetWorkspace_WsDocument, options);
        }
export type GetWorkspace_WsQueryHookResult = ReturnType<typeof useGetWorkspace_WsQuery>;
export type GetWorkspace_WsLazyQueryHookResult = ReturnType<typeof useGetWorkspace_WsLazyQuery>;
export type GetWorkspace_WsQueryResult = Apollo.QueryResult<IGetWorkspace_WsQuery, IGetWorkspace_WsQueryVariables>;
export const GetWorkspaceValue_WsDocument = gql`
    query GetWorkspaceValue_WS($value: WorkspaceValue_Input) {
  getWorkspaceValue(value: $value)
}
    `;

/**
 * __useGetWorkspaceValue_WsQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceValue_WsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceValue_WsQuery` 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 } = useGetWorkspaceValue_WsQuery({
 *   variables: {
 *      value: // value for 'value'
 *   },
 * });
 */
export function useGetWorkspaceValue_WsQuery(baseOptions?: Apollo.QueryHookOptions<IGetWorkspaceValue_WsQuery, IGetWorkspaceValue_WsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetWorkspaceValue_WsQuery, IGetWorkspaceValue_WsQueryVariables>(GetWorkspaceValue_WsDocument, options);
      }
export function useGetWorkspaceValue_WsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetWorkspaceValue_WsQuery, IGetWorkspaceValue_WsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetWorkspaceValue_WsQuery, IGetWorkspaceValue_WsQueryVariables>(GetWorkspaceValue_WsDocument, options);
        }
export type GetWorkspaceValue_WsQueryHookResult = ReturnType<typeof useGetWorkspaceValue_WsQuery>;
export type GetWorkspaceValue_WsLazyQueryHookResult = ReturnType<typeof useGetWorkspaceValue_WsLazyQuery>;
export type GetWorkspaceValue_WsQueryResult = Apollo.QueryResult<IGetWorkspaceValue_WsQuery, IGetWorkspaceValue_WsQueryVariables>;
export const AddServerNotificationDocument = gql`
    mutation AddServerNotification($notification: NotificationInput) {
  addNotification(notification: $notification)
}
    `;

/**
 * __useAddServerNotificationMutation__
 *
 * To run a mutation, you first call `useAddServerNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddServerNotificationMutation` 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 [addServerNotificationMutation, { data, loading, error }] = useAddServerNotificationMutation({
 *   variables: {
 *      notification: // value for 'notification'
 *   },
 * });
 */
export function useAddServerNotificationMutation(baseOptions?: Apollo.MutationHookOptions<IAddServerNotificationMutation, IAddServerNotificationMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IAddServerNotificationMutation, IAddServerNotificationMutationVariables>(AddServerNotificationDocument, options);
      }
export type AddServerNotificationMutationHookResult = ReturnType<typeof useAddServerNotificationMutation>;
export type AddServerNotificationMutationResult = Apollo.MutationResult<IAddServerNotificationMutation>;
export type AddServerNotificationMutationOptions = Apollo.BaseMutationOptions<IAddServerNotificationMutation, IAddServerNotificationMutationVariables>;
export const GetWorkspaceFolderContextDocument = gql`
    query GetWorkspaceFolderContext($arg: Arg_Input) {
  getWorkspaceFolderContext(arg: $arg) {
    id
    folders {
      ...WorkspaceFolder
    }
    configuration
  }
}
    ${WorkspaceFolderFragmentDoc}`;

/**
 * __useGetWorkspaceFolderContextQuery__
 *
 * To run a query within a React component, call `useGetWorkspaceFolderContextQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkspaceFolderContextQuery` 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 } = useGetWorkspaceFolderContextQuery({
 *   variables: {
 *      arg: // value for 'arg'
 *   },
 * });
 */
export function useGetWorkspaceFolderContextQuery(baseOptions?: Apollo.QueryHookOptions<IGetWorkspaceFolderContextQuery, IGetWorkspaceFolderContextQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IGetWorkspaceFolderContextQuery, IGetWorkspaceFolderContextQueryVariables>(GetWorkspaceFolderContextDocument, options);
      }
export function useGetWorkspaceFolderContextLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetWorkspaceFolderContextQuery, IGetWorkspaceFolderContextQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IGetWorkspaceFolderContextQuery, IGetWorkspaceFolderContextQueryVariables>(GetWorkspaceFolderContextDocument, options);
        }
export type GetWorkspaceFolderContextQueryHookResult = ReturnType<typeof useGetWorkspaceFolderContextQuery>;
export type GetWorkspaceFolderContextLazyQueryHookResult = ReturnType<typeof useGetWorkspaceFolderContextLazyQuery>;
export type GetWorkspaceFolderContextQueryResult = Apollo.QueryResult<IGetWorkspaceFolderContextQuery, IGetWorkspaceFolderContextQueryVariables>;
export const CodeLenseProviderDefinitionDocument = gql`
    mutation CodeLenseProviderDefinition($params: TextDocumentPositionParamsInput) {
  codeLenseProviderDefinition(params: $params) @client
}
    `;

/**
 * __useCodeLenseProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useCodeLenseProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCodeLenseProviderDefinitionMutation` 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 [codeLenseProviderDefinitionMutation, { data, loading, error }] = useCodeLenseProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useCodeLenseProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<ICodeLenseProviderDefinitionMutation, ICodeLenseProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ICodeLenseProviderDefinitionMutation, ICodeLenseProviderDefinitionMutationVariables>(CodeLenseProviderDefinitionDocument, options);
      }
export type CodeLenseProviderDefinitionMutationHookResult = ReturnType<typeof useCodeLenseProviderDefinitionMutation>;
export type CodeLenseProviderDefinitionMutationResult = Apollo.MutationResult<ICodeLenseProviderDefinitionMutation>;
export type CodeLenseProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<ICodeLenseProviderDefinitionMutation, ICodeLenseProviderDefinitionMutationVariables>;
export const CompletionProviderDefinitionDocument = gql`
    mutation CompletionProviderDefinition($params: TextDocumentPositionParamsInput) {
  completionProviderDefinition(params: $params) @client
}
    `;

/**
 * __useCompletionProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useCompletionProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCompletionProviderDefinitionMutation` 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 [completionProviderDefinitionMutation, { data, loading, error }] = useCompletionProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useCompletionProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<ICompletionProviderDefinitionMutation, ICompletionProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<ICompletionProviderDefinitionMutation, ICompletionProviderDefinitionMutationVariables>(CompletionProviderDefinitionDocument, options);
      }
export type CompletionProviderDefinitionMutationHookResult = ReturnType<typeof useCompletionProviderDefinitionMutation>;
export type CompletionProviderDefinitionMutationResult = Apollo.MutationResult<ICompletionProviderDefinitionMutation>;
export type CompletionProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<ICompletionProviderDefinitionMutation, ICompletionProviderDefinitionMutationVariables>;
export const DefinitionDefinitionDocument = gql`
    mutation DefinitionDefinition($params: TextDocumentPositionParamsInput) {
  definitionDefinition(params: $params) @client
}
    `;

/**
 * __useDefinitionDefinitionMutation__
 *
 * To run a mutation, you first call `useDefinitionDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDefinitionDefinitionMutation` 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 [definitionDefinitionMutation, { data, loading, error }] = useDefinitionDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useDefinitionDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IDefinitionDefinitionMutation, IDefinitionDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IDefinitionDefinitionMutation, IDefinitionDefinitionMutationVariables>(DefinitionDefinitionDocument, options);
      }
export type DefinitionDefinitionMutationHookResult = ReturnType<typeof useDefinitionDefinitionMutation>;
export type DefinitionDefinitionMutationResult = Apollo.MutationResult<IDefinitionDefinitionMutation>;
export type DefinitionDefinitionMutationOptions = Apollo.BaseMutationOptions<IDefinitionDefinitionMutation, IDefinitionDefinitionMutationVariables>;
export const DocumentHighLightProviderDefinitionDocument = gql`
    mutation DocumentHighLightProviderDefinition($params: TextDocumentPositionParamsInput) {
  documentHighLightProviderDefinition(params: $params) @client
}
    `;

/**
 * __useDocumentHighLightProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentHighLightProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentHighLightProviderDefinitionMutation` 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 [documentHighLightProviderDefinitionMutation, { data, loading, error }] = useDocumentHighLightProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useDocumentHighLightProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IDocumentHighLightProviderDefinitionMutation, IDocumentHighLightProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IDocumentHighLightProviderDefinitionMutation, IDocumentHighLightProviderDefinitionMutationVariables>(DocumentHighLightProviderDefinitionDocument, options);
      }
export type DocumentHighLightProviderDefinitionMutationHookResult = ReturnType<typeof useDocumentHighLightProviderDefinitionMutation>;
export type DocumentHighLightProviderDefinitionMutationResult = Apollo.MutationResult<IDocumentHighLightProviderDefinitionMutation>;
export type DocumentHighLightProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IDocumentHighLightProviderDefinitionMutation, IDocumentHighLightProviderDefinitionMutationVariables>;
export const DocumentFormattingProviderDefinitionDocument = gql`
    mutation DocumentFormattingProviderDefinition($params: TextDocumentPositionParamsInput) {
  documentFormattingProviderDefinition(params: $params) @client
}
    `;

/**
 * __useDocumentFormattingProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentFormattingProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentFormattingProviderDefinitionMutation` 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 [documentFormattingProviderDefinitionMutation, { data, loading, error }] = useDocumentFormattingProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useDocumentFormattingProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IDocumentFormattingProviderDefinitionMutation, IDocumentFormattingProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IDocumentFormattingProviderDefinitionMutation, IDocumentFormattingProviderDefinitionMutationVariables>(DocumentFormattingProviderDefinitionDocument, options);
      }
export type DocumentFormattingProviderDefinitionMutationHookResult = ReturnType<typeof useDocumentFormattingProviderDefinitionMutation>;
export type DocumentFormattingProviderDefinitionMutationResult = Apollo.MutationResult<IDocumentFormattingProviderDefinitionMutation>;
export type DocumentFormattingProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IDocumentFormattingProviderDefinitionMutation, IDocumentFormattingProviderDefinitionMutationVariables>;
export const HoverProviderDefinitionDocument = gql`
    mutation HoverProviderDefinition($params: TextDocumentPositionParamsInput) {
  hoverProviderDefinition(params: $params) @client
}
    `;

/**
 * __useHoverProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useHoverProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useHoverProviderDefinitionMutation` 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 [hoverProviderDefinitionMutation, { data, loading, error }] = useHoverProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useHoverProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IHoverProviderDefinitionMutation, IHoverProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IHoverProviderDefinitionMutation, IHoverProviderDefinitionMutationVariables>(HoverProviderDefinitionDocument, options);
      }
export type HoverProviderDefinitionMutationHookResult = ReturnType<typeof useHoverProviderDefinitionMutation>;
export type HoverProviderDefinitionMutationResult = Apollo.MutationResult<IHoverProviderDefinitionMutation>;
export type HoverProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IHoverProviderDefinitionMutation, IHoverProviderDefinitionMutationVariables>;
export const OpenLanguageDocumentDocument = gql`
    mutation OpenLanguageDocument($document: OpenDocumentParamsInput) {
  openLanguageDocument(params: $document) @client
}
    `;

/**
 * __useOpenLanguageDocumentMutation__
 *
 * To run a mutation, you first call `useOpenLanguageDocumentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOpenLanguageDocumentMutation` 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 [openLanguageDocumentMutation, { data, loading, error }] = useOpenLanguageDocumentMutation({
 *   variables: {
 *      document: // value for 'document'
 *   },
 * });
 */
export function useOpenLanguageDocumentMutation(baseOptions?: Apollo.MutationHookOptions<IOpenLanguageDocumentMutation, IOpenLanguageDocumentMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IOpenLanguageDocumentMutation, IOpenLanguageDocumentMutationVariables>(OpenLanguageDocumentDocument, options);
      }
export type OpenLanguageDocumentMutationHookResult = ReturnType<typeof useOpenLanguageDocumentMutation>;
export type OpenLanguageDocumentMutationResult = Apollo.MutationResult<IOpenLanguageDocumentMutation>;
export type OpenLanguageDocumentMutationOptions = Apollo.BaseMutationOptions<IOpenLanguageDocumentMutation, IOpenLanguageDocumentMutationVariables>;
export const ReferenceProviderDefinitionDocument = gql`
    mutation ReferenceProviderDefinition($params: TextDocumentPositionParamsInput) {
  referenceProviderDefinition(params: $params) @client
}
    `;

/**
 * __useReferenceProviderDefinitionMutation__
 *
 * To run a mutation, you first call `useReferenceProviderDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReferenceProviderDefinitionMutation` 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 [referenceProviderDefinitionMutation, { data, loading, error }] = useReferenceProviderDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useReferenceProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IReferenceProviderDefinitionMutation, IReferenceProviderDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IReferenceProviderDefinitionMutation, IReferenceProviderDefinitionMutationVariables>(ReferenceProviderDefinitionDocument, options);
      }
export type ReferenceProviderDefinitionMutationHookResult = ReturnType<typeof useReferenceProviderDefinitionMutation>;
export type ReferenceProviderDefinitionMutationResult = Apollo.MutationResult<IReferenceProviderDefinitionMutation>;
export type ReferenceProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IReferenceProviderDefinitionMutation, IReferenceProviderDefinitionMutationVariables>;
export const RenameDefinitionDocument = gql`
    mutation RenameDefinition($params: TextDocumentPositionParamsInput) {
  renameDefinition(params: $params) @client
}
    `;

/**
 * __useRenameDefinitionMutation__
 *
 * To run a mutation, you first call `useRenameDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRenameDefinitionMutation` 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 [renameDefinitionMutation, { data, loading, error }] = useRenameDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useRenameDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IRenameDefinitionMutation, IRenameDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IRenameDefinitionMutation, IRenameDefinitionMutationVariables>(RenameDefinitionDocument, options);
      }
export type RenameDefinitionMutationHookResult = ReturnType<typeof useRenameDefinitionMutation>;
export type RenameDefinitionMutationResult = Apollo.MutationResult<IRenameDefinitionMutation>;
export type RenameDefinitionMutationOptions = Apollo.BaseMutationOptions<IRenameDefinitionMutation, IRenameDefinitionMutationVariables>;
export const DocumentSymbolDefinitionDocument = gql`
    mutation DocumentSymbolDefinition($params: TextDocumentPositionParamsInput) {
  documentSymbolDefinition(params: $params) @client
}
    `;

/**
 * __useDocumentSymbolDefinitionMutation__
 *
 * To run a mutation, you first call `useDocumentSymbolDefinitionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDocumentSymbolDefinitionMutation` 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 [documentSymbolDefinitionMutation, { data, loading, error }] = useDocumentSymbolDefinitionMutation({
 *   variables: {
 *      params: // value for 'params'
 *   },
 * });
 */
export function useDocumentSymbolDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IDocumentSymbolDefinitionMutation, IDocumentSymbolDefinitionMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IDocumentSymbolDefinitionMutation, IDocumentSymbolDefinitionMutationVariables>(DocumentSymbolDefinitionDocument, options);
      }
export type DocumentSymbolDefinitionMutationHookResult = ReturnType<typeof useDocumentSymbolDefinitionMutation>;
export type DocumentSymbolDefinitionMutationResult = Apollo.MutationResult<IDocumentSymbolDefinitionMutation>;
export type DocumentSymbolDefinitionMutationOptions = Apollo.BaseMutationOptions<IDocumentSymbolDefinitionMutation, IDocumentSymbolDefinitionMutationVariables>;
export const UpdateModelDocument = gql`
    mutation UpdateModel($model: IModelInput) {
  updateModel(model: $model) @client
}
    `;

/**
 * __useUpdateModelMutation__
 *
 * To run a mutation, you first call `useUpdateModelMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateModelMutation` 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 [updateModelMutation, { data, loading, error }] = useUpdateModelMutation({
 *   variables: {
 *      model: // value for 'model'
 *   },
 * });
 */
export function useUpdateModelMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateModelMutation, IUpdateModelMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IUpdateModelMutation, IUpdateModelMutationVariables>(UpdateModelDocument, options);
      }
export type UpdateModelMutationHookResult = ReturnType<typeof useUpdateModelMutation>;
export type UpdateModelMutationResult = Apollo.MutationResult<IUpdateModelMutation>;
export type UpdateModelMutationOptions = Apollo.BaseMutationOptions<IUpdateModelMutation, IUpdateModelMutationVariables>;