@adminide-stack/extension-api 0.0.2-alpha.0

package/lib/interfaces/generated-models.d.ts

@@ -0,0 +1,3716 @@
+import { URI, UriComponents } from '@vscode-alt/monaco-editor/esm/vs/base/common/uri';
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import { MyContext } from '@adminide-stack/core';
+import * as Apollo from '@apollo/client';
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export declare type RequireFields<T, K extends keyof T> = {
+    [X in Exclude<keyof T, K>]?: T[X];
+} & {
+    [P in K]-?: NonNullable<T[P]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    AnyObject: any;
+    Date: any;
+    DateTime: any;
+    JSON: any;
+    JSONObject: any;
+    Observable: any;
+    Time: any;
+    URI: URI;
+    URIInput: URI | UriComponents;
+};
+export declare type IAdminIdeSettings = {
+    __typename?: 'AdminIdeSettings';
+    dummy?: Maybe<Scalars['Int']>;
+};
+export declare type IAnchor = {
+    __typename?: 'Anchor';
+    x?: Maybe<Scalars['Int']>;
+    y?: Maybe<Scalars['Int']>;
+    height?: Maybe<Scalars['Int']>;
+    width?: Maybe<Scalars['Int']>;
+};
+export declare type IAnchorInput = {
+    x?: Maybe<Scalars['Int']>;
+    y?: Maybe<Scalars['Int']>;
+    height?: Maybe<Scalars['Int']>;
+    width?: Maybe<Scalars['Int']>;
+};
+export declare type IArgsType = {
+    __typename?: 'ArgsType';
+    name?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    constraint?: Maybe<Scalars['String']>;
+};
+export declare type IAssets = {
+    __typename?: 'Assets';
+    Type?: Maybe<Scalars['String']>;
+    Content?: Maybe<Scalars['String']>;
+};
+export declare type IAuthor = {
+    __typename?: 'Author';
+    name?: Maybe<Scalars['String']>;
+};
+export declare type IBaseExtension = {
+    __typename?: 'BaseExtension';
+    type?: Maybe<IExtensionType>;
+    identifier?: Maybe<IExtensionIdentifier>;
+    /** @deprecated */
+    galleryIdentifier?: Maybe<IExtensionIdentifier>;
+    manifest?: Maybe<IExtensionManifest>;
+    location?: Maybe<Scalars['URI']>;
+};
+export declare type IBundles = {
+    __typename?: 'Bundles';
+    server?: Maybe<Scalars['String']>;
+    browser?: Maybe<Scalars['String']>;
+};
+export declare enum ICacheControlScope {
+    Public = "PUBLIC",
+    Private = "PRIVATE"
+}
+export declare enum IClientContainerService {
+    ExtensionController = "ExtensionController"
+}
+export declare type ICommandHandlerDescriptionType = {
+    __typename?: 'CommandHandlerDescriptionType';
+    description?: Maybe<Scalars['String']>;
+    args?: Maybe<Array<Maybe<IArgsType>>>;
+    returns?: Maybe<Scalars['String']>;
+};
+export declare type ICommandType = {
+    __typename?: 'CommandType';
+    id?: Maybe<Scalars['String']>;
+    handler?: Maybe<Scalars['AnyObject']>;
+    description?: Maybe<ICommandHandlerDescriptionType>;
+};
+export declare type ICommandsType = {
+    __typename?: 'CommandsType';
+    commands?: Maybe<Array<Maybe<ICommandType>>>;
+};
+export declare type IContextMenu = {
+    __typename?: 'ContextMenu';
+    id?: Maybe<Scalars['String']>;
+    isShow?: Maybe<Scalars['Boolean']>;
+    anchor?: Maybe<IAnchor>;
+    menuItems?: Maybe<Array<Maybe<IMenuItem>>>;
+};
+export declare type IContextMenuInput = {
+    isShow?: Maybe<Scalars['Boolean']>;
+    anchor?: Maybe<IAnchorInput>;
+    menuItems?: Maybe<Array<Maybe<IMenuItemInput>>>;
+};
+/** @deprecated use IExtensionContributions */
+export declare type IContributes = {
+    __typename?: 'Contributes';
+    menus?: Maybe<IMenus>;
+    actions?: Maybe<Array<Maybe<IContributionActions>>>;
+};
+export declare type IContributionAction = {
+    __typename?: 'ContributionAction';
+    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<IContributionActionRun>;
+};
+export declare type IContributionActionInput = {
+    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<IContributionActionRunInput>;
+};
+export declare type IContributionActionItem = {
+    __typename?: 'ContributionActionItem';
+    label?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+};
+export declare type IContributionActionRun = {
+    __typename?: 'ContributionActionRun';
+    type?: Maybe<IGraphqlCallType>;
+    document?: Maybe<Scalars['AnyObject']>;
+    variables?: Maybe<Scalars['AnyObject']>;
+};
+export declare type IContributionActionRunInput = {
+    type?: Maybe<IGraphqlCallType>;
+    document?: Maybe<Scalars['AnyObject']>;
+    variables?: Maybe<Scalars['AnyObject']>;
+};
+export declare type IContributionActions = {
+    __typename?: 'ContributionActions';
+    id?: Maybe<Scalars['String']>;
+    command?: Maybe<Scalars['String']>;
+    title?: Maybe<Scalars['String']>;
+    category?: Maybe<Scalars['String']>;
+    actionItem?: Maybe<IContributionActionItem>;
+};
+export declare type IContributionView = {
+    __typename?: 'ContributionView';
+    id?: Maybe<Scalars['ID']>;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type IDebugger = {
+    __typename?: 'Debugger';
+    label?: Maybe<Scalars['String']>;
+    type?: Maybe<Scalars['String']>;
+    runtime?: Maybe<Scalars['String']>;
+};
+/**  A CDECode product documentation page. */
+export declare 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'];
+};
+export declare type IDocumentFilter = {
+    __typename?: 'DocumentFilter';
+    language: Scalars['String'];
+    schema?: Maybe<Scalars['String']>;
+    pattern?: Maybe<Scalars['String']>;
+};
+/** Represents a null return value. */
+export declare type IEmptyResponse = {
+    __typename?: 'EmptyResponse';
+    alwaysNil?: Maybe<Scalars['String']>;
+};
+export declare type IEngines = {
+    __typename?: 'Engines';
+    node?: Maybe<Scalars['String']>;
+    vscode?: Maybe<Scalars['String']>;
+};
+export declare type IEnvironment = {
+    __typename?: 'Environment';
+    extHostLogsPath?: Maybe<Scalars['URI']>;
+    extensionDevelopmentLocationURI?: Maybe<Array<Maybe<Scalars['URI']>>>;
+    extensionEnabledProposedApi?: Maybe<Array<Maybe<Scalars['String']>>>;
+    extensionTestsLocationURI?: Maybe<Scalars['URI']>;
+    isExtensionDevelopment?: Maybe<Scalars['Boolean']>;
+    logExtensionHostCommunication?: Maybe<Scalars['Boolean']>;
+    logsPath?: Maybe<Scalars['String']>;
+    remoteAuthority?: Maybe<Scalars['String']>;
+    sessionId?: Maybe<Scalars['String']>;
+    sync?: Maybe<IEnvironmentSync>;
+    userDataPath?: Maybe<Scalars['String']>;
+    /**  Settings Sync  */
+    userDataSyncHome?: Maybe<Scalars['URI']>;
+    userDataSyncLogResource?: Maybe<Scalars['URI']>;
+    webviewCspSource?: Maybe<Scalars['String']>;
+    webviewExternalEndpoint?: Maybe<Scalars['String']>;
+    webviewResourceRoot?: Maybe<Scalars['String']>;
+};
+export declare type IEnvironmentPayload = {
+    sessionId?: Maybe<Scalars['String']>;
+    isExtensionDevelopment?: Maybe<Scalars['Boolean']>;
+    extensionDevelopmentLocationURI?: Maybe<Array<Maybe<Scalars['URI']>>>;
+    extensionTestsLocationURI?: Maybe<Scalars['URI']>;
+    extensionEnabledProposedApi?: Maybe<Array<Maybe<Scalars['String']>>>;
+    webviewResourceRoot?: Maybe<Scalars['String']>;
+    webviewCspSource?: Maybe<Scalars['String']>;
+};
+export declare enum IEnvironmentSync {
+    On = "on",
+    Off = "off",
+    Unset = "unset"
+}
+export declare type IExtensionColor = {
+    __typename?: 'ExtensionColor';
+    id?: Maybe<Scalars['ID']>;
+    description?: Maybe<Scalars['String']>;
+    defaults?: Maybe<IExtensionColorTypes>;
+};
+export declare type IExtensionColorTypes = {
+    __typename?: 'ExtensionColorTypes';
+    light?: Maybe<Scalars['String']>;
+    dark?: Maybe<Scalars['String']>;
+    highContrast?: Maybe<Scalars['String']>;
+};
+export declare type IExtensionConfiguration = {
+    __typename?: 'ExtensionConfiguration';
+    properties?: Maybe<Scalars['JSON']>;
+};
+export declare type IExtensionConfigurationProperty = {
+    __typename?: 'ExtensionConfigurationProperty';
+    description?: Maybe<Scalars['String']>;
+    type?: Maybe<Array<Maybe<Scalars['String']>>>;
+    defaults?: Maybe<Scalars['JSON']>;
+};
+export declare type IExtensionContributions = {
+    __typename?: 'ExtensionContributions';
+    /** @deprecated use commands */
+    actions?: Maybe<Array<Maybe<IContributionActions>>>;
+    /**
+     * @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<IContributionActions>>>;
+    /**
+     * @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>>>;
+};
+/**
+ * **!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 declare type IExtensionIdentifier = {
+    __typename?: 'ExtensionIdentifier';
+    id?: Maybe<Scalars['String']>;
+    uuid?: Maybe<Scalars['String']>;
+};
+export declare 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 declare type IExtensionJsonValidation = {
+    __typename?: 'ExtensionJSONValidation';
+    fileMatch?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['String']>;
+};
+export declare enum IExtensionKind {
+    Ui = "ui",
+    Workspace = "workspace"
+}
+export declare type IExtensionLanguage = {
+    __typename?: 'ExtensionLanguage';
+    id?: Maybe<Scalars['ID']>;
+    extensions?: Maybe<Array<Maybe<Scalars['String']>>>;
+    aliases?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export declare 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']>;
+    /** The raw JSON contents of the manifest. */
+    raw?: Maybe<Scalars['String']>;
+    /** Readme */
+    readme?: 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']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+    url?: 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 declare type IExtensionManifestBugs = {
+    __typename?: 'ExtensionManifestBugs';
+    url?: Maybe<Scalars['String']>;
+    email?: Maybe<Scalars['String']>;
+};
+export declare type IExtensionManifestRepository = {
+    __typename?: 'ExtensionManifestRepository';
+    type?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['String']>;
+};
+export declare type IExtensionPackageType = {
+    __typename?: 'ExtensionPackageType';
+    type?: Maybe<Scalars['String']>;
+};
+export declare 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 declare type IExtensionRegistryExtensionArgs = {
+    extensionID: Scalars['String'];
+};
+export declare 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 declare type IExtensionRegistryReleasesArgs = {
+    extensionID: Scalars['String'];
+};
+export declare type IExtensionRegistryPublishersArgs = {
+    first?: Maybe<Scalars['Int']>;
+};
+/**  The result of Mutation.extensionRegistry.createExtension. */
+export declare type IExtensionRegistryCreateExtensionResult = {
+    __typename?: 'ExtensionRegistryCreateExtensionResult';
+    /**  The newly created extension. */
+    extension: IRegistryExtension;
+};
+/**  The result of Mutation.extensionRegistry.publishExtension. */
+export declare type IExtensionRegistryPublishExtensionResult = {
+    __typename?: 'ExtensionRegistryPublishExtensionResult';
+    /**  The extension that was just published. */
+    extension: IRegistryExtension;
+};
+/**  The result of Mutation.extensionRegistry.updateExtension. */
+export declare type IExtensionRegistryUpdateExtensionResult = {
+    __typename?: 'ExtensionRegistryUpdateExtensionResult';
+    /**  The newly updated extension. */
+    extension: IRegistryExtension;
+};
+export declare 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 declare enum IExtensionType {
+    System = "System",
+    User = "User"
+}
+export declare type IFieldError = {
+    __typename?: 'FieldError';
+    field: Scalars['String'];
+    message: Scalars['String'];
+};
+export declare type IGalleryBanner = {
+    __typename?: 'GalleryBanner';
+    color?: Maybe<Scalars['String']>;
+    theme?: Maybe<Scalars['String']>;
+};
+export declare 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 declare type IGalleryExtensionAsset = {
+    __typename?: 'GalleryExtensionAsset';
+    uri?: Maybe<Scalars['String']>;
+    fallbackUri?: Maybe<Scalars['String']>;
+};
+export declare 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 declare 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 declare 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 declare type IGalleryFilter = {
+    value?: Maybe<Scalars['String']>;
+    filterType?: Maybe<Scalars['String']>;
+};
+export declare type IGalleryPager = {
+    __typename?: 'GalleryPager';
+    page?: Maybe<Scalars['Int']>;
+    total?: Maybe<Scalars['Int']>;
+    pageSize?: Maybe<Scalars['Int']>;
+    firstPage?: Maybe<Array<Maybe<IGalleryExtension>>>;
+};
+export declare 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 declare type IGeoLocation = {
+    __typename?: 'GeoLocation';
+    coordinates?: Maybe<Array<Maybe<Scalars['Float']>>>;
+};
+export declare type IGrammar = {
+    __typename?: 'Grammar';
+    language?: Maybe<Scalars['String']>;
+};
+export declare enum IGraphqlCallType {
+    Mutation = "mutation",
+    Query = "query"
+}
+export declare type IHover = {
+    contents?: Maybe<IMarkupContent>;
+    range?: Maybe<IRange>;
+};
+export declare type IIActivationRequest = {
+    env?: Maybe<Array<Maybe<Scalars['String']>>>;
+    extensionID: Scalars['ID'];
+};
+export declare 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 declare type IIBehaviorSubjectValue = {
+    __typename?: 'IBehaviorSubjectValue';
+    provider?: Maybe<Scalars['String']>;
+    registrationOptions?: Maybe<IIDocumentSelector>;
+};
+export declare 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 declare type IIDocumentSelector = {
+    __typename?: 'IDocumentSelector';
+    documentSelector?: Maybe<Scalars['JSON']>;
+};
+export declare type IIModel = {
+    __typename?: 'IModel';
+    roots?: Maybe<IIWorkspaceRoot>;
+    visibleViewComponents?: Maybe<Array<Maybe<IIViewComponentData>>>;
+};
+export declare type IIModelInput = {
+    roots?: Maybe<IIWorkspaceRootInput>;
+    visibleViewComponents?: Maybe<Array<Maybe<IIViewComponentDataInput>>>;
+};
+export declare 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 declare type IIResourceUtilizationSettings = {
+    subTopic?: Maybe<Scalars['String']>;
+    adminApiNamespace?: Maybe<Scalars['String']>;
+};
+export declare 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 declare type IISwitchMapOperator = {
+    __typename?: 'ISwitchMapOperator';
+    project?: Maybe<Scalars['String']>;
+};
+export declare type IITextDocumentIdentifier = {
+    uri?: Maybe<Scalars['URI']>;
+    /** just to statisfy few issues */
+    languageId?: Maybe<Scalars['String']>;
+};
+export declare type IIViewComponentData = {
+    __typename?: 'IViewComponentData';
+    type?: Maybe<Scalars['String']>;
+    item?: Maybe<ITextDocumentItem>;
+    isActive?: Maybe<Scalars['Boolean']>;
+};
+export declare type IIViewComponentDataInput = {
+    type?: Maybe<Scalars['String']>;
+    item?: Maybe<ITextDocumentItemInput>;
+    isActive?: Maybe<Scalars['Boolean']>;
+};
+export declare type IIWorkspaceRoot = {
+    __typename?: 'IWorkspaceRoot';
+    url?: Maybe<Scalars['String']>;
+};
+export declare type IIWorkspaceRootInput = {
+    url?: Maybe<Scalars['String']>;
+};
+export declare type IInstalledExtension = {
+    __typename?: 'InstalledExtension';
+    extension?: Maybe<IGalleryExtension>;
+    identifier?: Maybe<IExtensionIdentifier>;
+    galleryIdentifier?: Maybe<IExtensionIdentifier>;
+};
+export declare 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']>;
+};
+export declare 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 declare 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 declare type ILocation = {
+    rangeOrUri?: Maybe<IPosition>;
+    uriRangeOrPosition?: Maybe<Scalars['String']>;
+    range?: Maybe<IPosition>;
+    uri?: Maybe<Scalars['String']>;
+};
+export declare type IMarkupContent = {
+    value?: Maybe<Scalars['String']>;
+    kind?: Maybe<IMarkupKind>;
+};
+export declare enum IMarkupKind {
+    Plaintext = "plaintext",
+    Markdown = "markdown"
+}
+export declare enum IMenuId {
+    CommandPalette = "CommandPalette",
+    MenubarAppearanceMenu = "MenubarAppearanceMenu",
+    MenubarDebugMenu = "MenubarDebugMenu",
+    MenubarEditMenu = "MenubarEditMenu",
+    MenubarFileMenu = "MenubarFileMenu",
+    MenubarGoMenu = "MenubarGoMenu",
+    MenubarNewBreakpointMenu = "MenubarNewBreakpointMenu",
+    MenubarPreferencesMenu = "MenubarPreferencesMenu",
+    MenubarRecentMenu = "MenubarRecentMenu",
+    MenubarSelectionMenu = "MenubarSelectionMenu",
+    MenubarSwitchEditorMenu = "MenubarSwitchEditorMenu",
+    MenubarSwitchGroupMenu = "MenubarSwitchGroupMenu",
+    MenubarTeamMenu = "MenubarTeamMenu",
+    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 declare type IMenuItem = {
+    __typename?: 'MenuItem';
+    id?: Maybe<Scalars['String']>;
+    label?: Maybe<Scalars['String']>;
+    enabled?: Maybe<Scalars['Boolean']>;
+    run?: Maybe<IContributionActionRun>;
+};
+export declare type IMenuItemAction = {
+    __typename?: 'MenuItemAction';
+    action?: Maybe<Scalars['String']>;
+    when?: Maybe<Scalars['String']>;
+};
+export declare type IMenuItemActionContext = {
+    __typename?: 'MenuItemActionContext';
+    context?: Maybe<Array<Maybe<IMenuItemAction>>>;
+};
+export declare type IMenuItemActionDebug = {
+    __typename?: 'MenuItemActionDebug';
+    callstack?: Maybe<IMenuItemActionContext>;
+    toolbar?: Maybe<Array<Maybe<IMenuItemAction>>>;
+};
+export declare type IMenuItemActionEditor = {
+    __typename?: 'MenuItemActionEditor';
+    context?: Maybe<Array<Maybe<IMenuItemAction>>>;
+    title?: Maybe<IMenuItemActionEditorTitle>;
+};
+export declare type IMenuItemActionEditorTitle = {
+    __typename?: 'MenuItemActionEditorTitle';
+    own?: Maybe<Array<Maybe<IMenuItemAction>>>;
+    context?: Maybe<Array<Maybe<IMenuItemAction>>>;
+};
+export declare 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 declare type IMenuItemActionScmChange = {
+    __typename?: 'MenuItemActionScmChange';
+    title?: Maybe<Array<Maybe<IMenuItemAction>>>;
+};
+export declare type IMenuItemActionView = {
+    __typename?: 'MenuItemActionView';
+    /**  The contributed view title menu  */
+    title?: Maybe<Array<Maybe<IMenuItemAction>>>;
+    /**  The contributed view item context menu  */
+    item?: Maybe<IMenuItemActionContext>;
+};
+export declare type IMenuItemInput = {
+    id?: Maybe<Scalars['String']>;
+    label?: Maybe<Scalars['String']>;
+    enabled?: Maybe<Scalars['Boolean']>;
+    run?: Maybe<IContributionActionRunInput>;
+};
+export declare 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 declare type IMessageLink = {
+    __typename?: 'MessageLink';
+    name?: Maybe<Scalars['String']>;
+    href?: Maybe<Scalars['String']>;
+    offset?: Maybe<Scalars['Int']>;
+    length?: Maybe<Scalars['Int']>;
+};
+export declare type IMessageLinkInput = {
+    name?: Maybe<Scalars['String']>;
+    href?: Maybe<Scalars['String']>;
+    offset?: Maybe<Scalars['Int']>;
+    length?: Maybe<Scalars['Int']>;
+};
+/**  All Moleculer Topic names are extended from this. */
+export declare enum IMoleculerServiceName {
+    Dummy = "dummy"
+}
+export declare type IMutation = {
+    __typename?: 'Mutation';
+    activate?: Maybe<Scalars['Boolean']>;
+    addNotification?: Maybe<Scalars['Boolean']>;
+    closeNotification?: Maybe<Scalars['Boolean']>;
+    codeLenseProviderDefinition?: Maybe<Scalars['Observable']>;
+    completionProviderDefinition?: Maybe<Scalars['Observable']>;
+    copy?: Maybe<Scalars['Boolean']>;
+    /**  Create a new extension in the extension registry. */
+    createExtension: IRegistryExtension;
+    definitionDefinition?: Maybe<Scalars['Observable']>;
+    /**
+     * Delete an extension from the extension registry.
+     *
+     * Only authorized extension publishers may perform this mutation.
+     */
+    deleteExtension: IEmptyResponse;
+    documentFormattingProviderDefinition?: Maybe<Scalars['Observable']>;
+    documentHighLightProviderDefinition?: Maybe<Scalars['Observable']>;
+    documentSymbolDefinition?: Maybe<Scalars['Observable']>;
+    dummy?: Maybe<Scalars['Int']>;
+    handler?: Maybe<Scalars['Boolean']>;
+    hideContextMenu?: Maybe<Scalars['Boolean']>;
+    hoverProviderDefinition?: Maybe<Scalars['Observable']>;
+    install?: Maybe<IExtensionIdentifier>;
+    notify?: Maybe<Scalars['Boolean']>;
+    notifyError?: Maybe<Scalars['Boolean']>;
+    notifyInfo?: Maybe<Scalars['Boolean']>;
+    notifyPrompt?: Maybe<Scalars['Boolean']>;
+    notifyWarn?: Maybe<Scalars['Boolean']>;
+    openLanguageDocument?: Maybe<Scalars['Observable']>;
+    /**
+     * 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;
+    referenceProviderDefinition?: Maybe<Scalars['Observable']>;
+    removeExtension?: Maybe<Scalars['Boolean']>;
+    renameDefinition?: Maybe<Scalars['Observable']>;
+    runMenuAction?: Maybe<Scalars['Boolean']>;
+    showContextMenu?: Maybe<Scalars['Boolean']>;
+    startExtensionHost?: Maybe<Scalars['Boolean']>;
+    /**
+     * Update an extension in the extension registry.
+     *
+     * Only authorized extension publishers may perform this mutation.
+     */
+    updateExtension: IRegistryExtension;
+    /** @deprecated need to remove */
+    updateModel?: Maybe<Scalars['Boolean']>;
+};
+export declare type IMutationActivateArgs = {
+    request: IIActivationRequest;
+};
+export declare type IMutationAddNotificationArgs = {
+    notification?: Maybe<INotificationInput>;
+};
+export declare type IMutationCloseNotificationArgs = {
+    index?: Maybe<Scalars['Int']>;
+};
+export declare type IMutationCodeLenseProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationCompletionProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationCopyArgs = {
+    value?: Maybe<Scalars['String']>;
+};
+export declare type IMutationCreateExtensionArgs = {
+    publisher: Scalars['ID'];
+    name: Scalars['String'];
+};
+export declare type IMutationDefinitionDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationDeleteExtensionArgs = {
+    extension: Scalars['ID'];
+};
+export declare type IMutationDocumentFormattingProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationDocumentHighLightProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationDocumentSymbolDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationHandlerArgs = {
+    arg?: Maybe<IContributionActionRunInput>;
+};
+export declare type IMutationHoverProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationInstallArgs = {
+    vsix: Scalars['String'];
+};
+export declare type IMutationNotifyArgs = {
+    notification?: Maybe<INotificationInput>;
+};
+export declare type IMutationNotifyErrorArgs = {
+    message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
+};
+export declare type IMutationNotifyInfoArgs = {
+    message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
+};
+export declare type IMutationNotifyPromptArgs = {
+    severity?: Maybe<INotificationSeverity>;
+    message?: Maybe<Scalars['String']>;
+    choices?: Maybe<Array<Maybe<IPromptChoiceInput>>>;
+    options?: Maybe<IPromptOptionsInput>;
+};
+export declare type IMutationNotifyWarnArgs = {
+    message?: Maybe<Array<Maybe<INotificationMessageInput>>>;
+};
+export declare type IMutationOpenLanguageDocumentArgs = {
+    params?: Maybe<IOpenDocumentParamsInput>;
+};
+export declare 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 declare type IMutationReferenceProviderDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationRemoveExtensionArgs = {
+    id: Scalars['String'];
+};
+export declare type IMutationRenameDefinitionArgs = {
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+};
+export declare type IMutationRunMenuActionArgs = {
+    argument?: Maybe<IContributionActionRunInput>;
+};
+export declare type IMutationShowContextMenuArgs = {
+    delegate?: Maybe<IContextMenuInput>;
+};
+export declare type IMutationStartExtensionHostArgs = {
+    request?: Maybe<Scalars['String']>;
+};
+export declare type IMutationUpdateExtensionArgs = {
+    extension: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+};
+export declare type IMutationUpdateModelArgs = {
+    model?: Maybe<IIModelInput>;
+};
+/** An object with an ID. */
+export declare type INode = {
+    /** The ID of the node. */
+    id: Scalars['ID'];
+};
+export declare type INotification = {
+    __typename?: 'Notification';
+    index?: Maybe<Scalars['Boolean']>;
+    /** The severity of the notification. Either `Info`, `Warning` or `Error`. */
+    severity?: Maybe<INotificationSeverity>;
+    /**
+     * 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']>;
+    /**
+     * ContributionActions 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 declare 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<IContributionAction>>>;
+    /**
+     * 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<IContributionAction>>>;
+};
+export declare type INotificationActionsInput = {
+    primary?: Maybe<Array<Maybe<IContributionActionInput>>>;
+    secondary?: Maybe<Array<Maybe<IContributionActionInput>>>;
+};
+export declare 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 declare enum INotificationChangeType {
+    Add = "ADD",
+    Change = "CHANGE",
+    Remove = "REMOVE"
+}
+export declare type INotificationInput = {
+    severity?: Maybe<INotificationSeverity>;
+    message?: Maybe<INotificationMessageInput>;
+    source?: Maybe<Scalars['String']>;
+    actions?: Maybe<INotificationActionsInput>;
+    sticky?: Maybe<Scalars['Boolean']>;
+};
+export declare type INotificationMessage = {
+    __typename?: 'NotificationMessage';
+    raw?: Maybe<Scalars['String']>;
+    original?: Maybe<INotificationMessage>;
+    value?: Maybe<Scalars['String']>;
+    links?: Maybe<Array<Maybe<IMessageLink>>>;
+};
+export declare type INotificationMessageInput = {
+    raw?: Maybe<Scalars['String']>;
+    original?: Maybe<INotificationMessageInput>;
+    value?: Maybe<Scalars['String']>;
+    links?: Maybe<Array<Maybe<IMessageLinkInput>>>;
+};
+export declare enum INotificationSeverity {
+    Ignore = "Ignore",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error"
+}
+export declare type INotificationViewItem = {
+    __typename?: 'NotificationViewItem';
+    severity?: Maybe<INotificationSeverity>;
+    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 declare enum INotificationViewItemLabelKind {
+    Severity = "SEVERITY",
+    Message = "MESSAGE",
+    Actions = "ACTIONS",
+    Progress = "PROGRESS"
+}
+export declare type INotificationViewItemProgress = {
+    __typename?: 'NotificationViewItemProgress';
+    state?: Maybe<INotificationViewItemProgressState>;
+};
+export declare 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 declare type INotifications = {
+    __typename?: 'Notifications';
+    notifications?: Maybe<Array<Maybe<INotification>>>;
+};
+export declare type IOpenDocumentParamsInput = {
+    textDocument?: Maybe<IOpenDocumentTextParamsInput>;
+};
+export declare type IOpenDocumentTextParamsInput = {
+    uri?: Maybe<Scalars['String']>;
+    languageId?: Maybe<Scalars['String']>;
+    version?: Maybe<Scalars['Int']>;
+    text?: Maybe<Scalars['String']>;
+};
+export declare type IPageInfo = {
+    __typename?: 'PageInfo';
+    hasNextPage: 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 declare 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 declare type IPositionInput = {
+    line?: Maybe<Scalars['Int']>;
+    character?: Maybe<Scalars['Int']>;
+    lineNumber?: Maybe<Scalars['Int']>;
+    column?: Maybe<Scalars['Int']>;
+};
+export declare type IProcessMonitoring = {
+    __typename?: 'ProcessMonitoring';
+    cpu?: Maybe<Scalars['Float']>;
+    memory?: Maybe<Scalars['Float']>;
+};
+export declare 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 declare type IPromptChoiceRun = {
+    type?: Maybe<IGraphqlCallType>;
+    document?: Maybe<Scalars['AnyObject']>;
+    variables?: Maybe<Scalars['AnyObject']>;
+};
+export declare type IPromptOptionsCancel = {
+    type?: Maybe<IGraphqlCallType>;
+    document?: Maybe<Scalars['AnyObject']>;
+    variables?: Maybe<Scalars['AnyObject']>;
+};
+export declare 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 declare 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 declare type IProvideTextDocumentLocationSignatureInput = {
+    textDocument?: Maybe<ITextDocumentIdentifierInput>;
+    position?: Maybe<IPositionInput>;
+    rangeOrUri?: Maybe<IPositionInput>;
+    uriRangeOrPosition?: Maybe<Scalars['String']>;
+    range?: Maybe<IPositionInput>;
+    uri?: Maybe<Scalars['String']>;
+};
+export declare type IQuery = {
+    __typename?: 'Query';
+    contextMenu?: Maybe<IContextMenu>;
+    /**
+     * 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>;
+    extension?: Maybe<IRegistryExtension>;
+    /**  The extension registry.  */
+    extensionRegistry: IExtensionRegistry;
+    extensions: IRegistryExtensionConnection;
+    gallery?: Maybe<IGalleryPager>;
+    galleryExtension?: Maybe<IGalleryExtension>;
+    installed?: Maybe<Array<Maybe<IInstalledExtension>>>;
+    instances?: Maybe<Array<Maybe<IExtensionInstance>>>;
+    /** Looks up a node by ID. */
+    node?: Maybe<INode>;
+    notifications?: Maybe<INotifications>;
+    registerProvider?: Maybe<Scalars['Boolean']>;
+    releases?: Maybe<Array<Maybe<IExtensionRelease>>>;
+    showNotification?: Maybe<Scalars['Boolean']>;
+};
+export declare type IQueryDocSitePageArgs = {
+    path: Scalars['String'];
+};
+export declare type IQueryExtensionArgs = {
+    extensionID: Scalars['String'];
+};
+export declare 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 declare type IQueryGalleryArgs = {
+    query?: Maybe<IGalleryQueryInput>;
+};
+export declare type IQueryGalleryExtensionArgs = {
+    extensionID: Scalars['String'];
+};
+export declare type IQueryNodeArgs = {
+    id: Scalars['ID'];
+};
+export declare type IQueryRegisterProviderArgs = {
+    registrationOptions?: Maybe<ITextDocumentRegistrationOptionsInput>;
+    provider?: Maybe<IProvideTextDocumentLocationSignatureInput>;
+};
+export declare type IQueryReleasesArgs = {
+    extensionID: Scalars['String'];
+};
+export declare type IQueryShowNotificationArgs = {
+    notification?: Maybe<INotificationInput>;
+};
+/**
+ * @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 declare 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 declare type IRangeInput = {
+    endColumn?: Maybe<Scalars['Int']>;
+    endLineNumber?: Maybe<Scalars['Int']>;
+    startColumn?: Maybe<Scalars['Int']>;
+    startLineNumber?: Maybe<Scalars['Int']>;
+};
+export declare type IRegistryEntry = {
+    __typename?: 'RegistryEntry';
+    registrationOptions?: Maybe<ITextDocumentRegistrationOptions>;
+    provider?: Maybe<Scalars['String']>;
+};
+/**  An extenion's listing in the extension registry. */
+export declare 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 declare 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 declare type IRegistryPublisher = {
+    __typename?: 'RegistryPublisher';
+    UserId?: Maybe<Scalars['String']>;
+};
+/**  A list of publishers of extensions in the registry. */
+export declare 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 declare type IScripts = {
+    __typename?: 'Scripts';
+    cdebasebuild?: Maybe<Scalars['String']>;
+    cdebasepublish?: Maybe<Scalars['String']>;
+};
+export declare type ISnippet = {
+    __typename?: 'Snippet';
+    language?: Maybe<Scalars['String']>;
+};
+export declare type ISort = {
+    key: Scalars['String'];
+    value: ISortEnum;
+};
+export declare enum ISortEnum {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export declare type ISubscription = {
+    __typename?: 'Subscription';
+    dummy?: Maybe<Scalars['Int']>;
+};
+export declare type ITextDocumentIdentifier = IITextDocumentIdentifier & {
+    __typename?: 'TextDocumentIdentifier';
+    uri?: Maybe<Scalars['URI']>;
+    languageId?: Maybe<Scalars['String']>;
+};
+export declare type ITextDocumentIdentifierInput = {
+    uri?: Maybe<Scalars['URI']>;
+};
+/** An item to transfer a text document from the client to the server. */
+export declare 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 declare type ITextDocumentItemInput = {
+    uri?: Maybe<Scalars['String']>;
+    languageId?: Maybe<Scalars['String']>;
+    text?: Maybe<Scalars['String']>;
+};
+export declare type ITextDocumentPositionParams = {
+    textDocument?: Maybe<ITextDocumentIdentifier>;
+    position?: Maybe<IPosition>;
+};
+export declare type ITextDocumentPositionParamsInput = {
+    textDocument?: Maybe<ITextDocumentIdentifierInput>;
+    position?: Maybe<IPositionInput>;
+};
+export declare type ITextDocumentRegistrationOptions = {
+    __typename?: 'TextDocumentRegistrationOptions';
+    documentSelector?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export declare type ITextDocumentRegistrationOptionsInput = {
+    documentSelector?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+export declare type IThemeLabel = {
+    __typename?: 'ThemeLabel';
+    label?: Maybe<Scalars['String']>;
+    uiTheme?: Maybe<Scalars['String']>;
+    path?: Maybe<Scalars['String']>;
+};
+export declare type IViewContainer = {
+    __typename?: 'ViewContainer';
+    id?: Maybe<Scalars['ID']>;
+    title?: Maybe<Scalars['String']>;
+};
+export declare type ICopyMutationVariables = Exact<{
+    value?: Maybe<Scalars['String']>;
+}>;
+export declare type ICopyMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'copy'>);
+export declare type IRunMenuActionMutationVariables = Exact<{
+    argument?: Maybe<IContributionActionRunInput>;
+}>;
+export declare type IRunMenuActionMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'runMenuAction'>);
+export declare type IHideContextMenuMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type IHideContextMenuMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'hideContextMenu'>);
+export declare type IShowContextMenuMutationVariables = Exact<{
+    delegate?: Maybe<IContextMenuInput>;
+}>;
+export declare type IShowContextMenuMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'showContextMenu'>);
+export declare type IInstallMutationVariables = Exact<{
+    vsix: Scalars['String'];
+}>;
+export declare type IInstallMutation = ({
+    __typename?: 'Mutation';
+} & {
+    install?: Maybe<({
+        __typename?: 'ExtensionIdentifier';
+    } & Pick<IExtensionIdentifier, 'id' | 'uuid'>)>;
+});
+export declare type IProviderDefinitionMutationVariables = Exact<{
+    params?: Maybe<ITextDocumentPositionParamsInput>;
+}>;
+export declare type IProviderDefinitionMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'hoverProviderDefinition'>);
+export declare type IRemoveMutationVariables = Exact<{
+    id: Scalars['String'];
+}>;
+export declare type IRemoveMutation = ({
+    __typename?: 'Mutation';
+} & Pick<IMutation, 'removeExtension'>);
+export declare type IContextMenuQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare 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?: 'ContributionActionRun';
+            } & Pick<IContributionActionRun, 'type' | 'document' | 'variables'>)>;
+        })>>>;
+    })>;
+});
+export declare type IGalleryExtensionQueryVariables = Exact<{
+    extensionID: Scalars['String'];
+}>;
+export declare 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 declare type IExtensionsByLimitQueryVariables = Exact<{
+    first: Scalars['Int'];
+    prioritizeExtensionIDs: Array<Scalars['String']> | Scalars['String'];
+}>;
+export declare type IExtensionsByLimitQuery = ({
+    __typename?: 'Query';
+} & {
+    extensions: ({
+        __typename?: 'RegistryExtensionConnection';
+    } & {
+        nodes: Array<({
+            __typename?: 'RegistryExtension';
+        } & Pick<IRegistryExtension, 'id' | 'url' | 'extensionID' | 'viewerCanAdminister'> & {
+            manifest?: Maybe<({
+                __typename?: 'ExtensionManifest';
+            } & Pick<IExtensionManifest, 'bundleURL' | 'raw' | 'name' | 'activationEvents'>)>;
+        })>;
+    });
+});
+export declare type IGalleryQueryVariables = Exact<{
+    query?: Maybe<IGalleryQueryInput>;
+}>;
+export declare 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 declare type IInstalledExtensionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare 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 declare type INotificationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare 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?: 'ContributionAction';
+                } & Pick<IContributionAction, 'id' | 'label' | 'tooltip' | 'class' | 'enabled' | 'checked' | 'radio'> & {
+                    run?: Maybe<({
+                        __typename?: 'ContributionActionRun';
+                    } & Pick<IContributionActionRun, 'type' | 'document' | 'variables'>)>;
+                })>>>;
+                secondary?: Maybe<Array<Maybe<({
+                    __typename?: 'ContributionAction';
+                } & Pick<IContributionAction, 'id' | 'label' | 'tooltip' | 'class' | 'enabled' | 'checked' | 'radio'> & {
+                    run?: Maybe<({
+                        __typename?: 'ContributionActionRun';
+                    } & Pick<IContributionActionRun, 'type' | 'document' | 'variables'>)>;
+                })>>>;
+            })>;
+        })>>>;
+    })>;
+});
+export declare type IShowNotificationQueryVariables = Exact<{
+    notification?: Maybe<INotificationInput>;
+}>;
+export declare type IShowNotificationQuery = ({
+    __typename?: 'Query';
+} & Pick<IQuery, 'showNotification'>);
+export declare const CopyDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useCopyMutation(baseOptions?: Apollo.MutationHookOptions<ICopyMutation, ICopyMutationVariables>): Apollo.MutationTuple<ICopyMutation, Exact<{
+    value?: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type CopyMutationHookResult = ReturnType<typeof useCopyMutation>;
+export declare type CopyMutationResult = Apollo.MutationResult<ICopyMutation>;
+export declare type CopyMutationOptions = Apollo.BaseMutationOptions<ICopyMutation, ICopyMutationVariables>;
+export declare const RunMenuActionDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useRunMenuActionMutation(baseOptions?: Apollo.MutationHookOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>): Apollo.MutationTuple<IRunMenuActionMutation, Exact<{
+    argument?: IContributionActionRunInput;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type RunMenuActionMutationHookResult = ReturnType<typeof useRunMenuActionMutation>;
+export declare type RunMenuActionMutationResult = Apollo.MutationResult<IRunMenuActionMutation>;
+export declare type RunMenuActionMutationOptions = Apollo.BaseMutationOptions<IRunMenuActionMutation, IRunMenuActionMutationVariables>;
+export declare const HideContextMenuDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useHideContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>): Apollo.MutationTuple<IHideContextMenuMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type HideContextMenuMutationHookResult = ReturnType<typeof useHideContextMenuMutation>;
+export declare type HideContextMenuMutationResult = Apollo.MutationResult<IHideContextMenuMutation>;
+export declare type HideContextMenuMutationOptions = Apollo.BaseMutationOptions<IHideContextMenuMutation, IHideContextMenuMutationVariables>;
+export declare const ShowContextMenuDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useShowContextMenuMutation(baseOptions?: Apollo.MutationHookOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>): Apollo.MutationTuple<IShowContextMenuMutation, Exact<{
+    delegate?: IContextMenuInput;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type ShowContextMenuMutationHookResult = ReturnType<typeof useShowContextMenuMutation>;
+export declare type ShowContextMenuMutationResult = Apollo.MutationResult<IShowContextMenuMutation>;
+export declare type ShowContextMenuMutationOptions = Apollo.BaseMutationOptions<IShowContextMenuMutation, IShowContextMenuMutationVariables>;
+export declare const InstallDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useInstallMutation(baseOptions?: Apollo.MutationHookOptions<IInstallMutation, IInstallMutationVariables>): Apollo.MutationTuple<IInstallMutation, Exact<{
+    vsix: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type InstallMutationHookResult = ReturnType<typeof useInstallMutation>;
+export declare type InstallMutationResult = Apollo.MutationResult<IInstallMutation>;
+export declare type InstallMutationOptions = Apollo.BaseMutationOptions<IInstallMutation, IInstallMutationVariables>;
+export declare const ProviderDefinitionDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useProviderDefinitionMutation(baseOptions?: Apollo.MutationHookOptions<IProviderDefinitionMutation, IProviderDefinitionMutationVariables>): Apollo.MutationTuple<IProviderDefinitionMutation, Exact<{
+    params?: ITextDocumentPositionParamsInput;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type ProviderDefinitionMutationHookResult = ReturnType<typeof useProviderDefinitionMutation>;
+export declare type ProviderDefinitionMutationResult = Apollo.MutationResult<IProviderDefinitionMutation>;
+export declare type ProviderDefinitionMutationOptions = Apollo.BaseMutationOptions<IProviderDefinitionMutation, IProviderDefinitionMutationVariables>;
+export declare const RemoveDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useRemoveMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveMutation, IRemoveMutationVariables>): Apollo.MutationTuple<IRemoveMutation, Exact<{
+    id: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export declare type RemoveMutationHookResult = ReturnType<typeof useRemoveMutation>;
+export declare type RemoveMutationResult = Apollo.MutationResult<IRemoveMutation>;
+export declare type RemoveMutationOptions = Apollo.BaseMutationOptions<IRemoveMutation, IRemoveMutationVariables>;
+export declare const ContextMenuDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useContextMenuQuery(baseOptions?: Apollo.QueryHookOptions<IContextMenuQuery, IContextMenuQueryVariables>): Apollo.QueryResult<IContextMenuQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useContextMenuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IContextMenuQuery, IContextMenuQueryVariables>): Apollo.LazyQueryResultTuple<IContextMenuQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type ContextMenuQueryHookResult = ReturnType<typeof useContextMenuQuery>;
+export declare type ContextMenuLazyQueryHookResult = ReturnType<typeof useContextMenuLazyQuery>;
+export declare type ContextMenuQueryResult = Apollo.QueryResult<IContextMenuQuery, IContextMenuQueryVariables>;
+export declare const GalleryExtensionDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useGalleryExtensionQuery(baseOptions: Apollo.QueryHookOptions<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>): Apollo.QueryResult<IGalleryExtensionQuery, Exact<{
+    extensionID: string;
+}>>;
+export declare function useGalleryExtensionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>): Apollo.LazyQueryResultTuple<IGalleryExtensionQuery, Exact<{
+    extensionID: string;
+}>>;
+export declare type GalleryExtensionQueryHookResult = ReturnType<typeof useGalleryExtensionQuery>;
+export declare type GalleryExtensionLazyQueryHookResult = ReturnType<typeof useGalleryExtensionLazyQuery>;
+export declare type GalleryExtensionQueryResult = Apollo.QueryResult<IGalleryExtensionQuery, IGalleryExtensionQueryVariables>;
+export declare const ExtensionsByLimitDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useExtensionsByLimitQuery(baseOptions: Apollo.QueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>): Apollo.QueryResult<IExtensionsByLimitQuery, Exact<{
+    first: number;
+    prioritizeExtensionIDs: string | string[];
+}>>;
+export declare function useExtensionsByLimitLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>): Apollo.LazyQueryResultTuple<IExtensionsByLimitQuery, Exact<{
+    first: number;
+    prioritizeExtensionIDs: string | string[];
+}>>;
+export declare type ExtensionsByLimitQueryHookResult = ReturnType<typeof useExtensionsByLimitQuery>;
+export declare type ExtensionsByLimitLazyQueryHookResult = ReturnType<typeof useExtensionsByLimitLazyQuery>;
+export declare type ExtensionsByLimitQueryResult = Apollo.QueryResult<IExtensionsByLimitQuery, IExtensionsByLimitQueryVariables>;
+export declare const GalleryDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useGalleryQuery(baseOptions?: Apollo.QueryHookOptions<IGalleryQuery, IGalleryQueryVariables>): Apollo.QueryResult<IGalleryQuery, Exact<{
+    query?: IGalleryQueryInput;
+}>>;
+export declare function useGalleryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGalleryQuery, IGalleryQueryVariables>): Apollo.LazyQueryResultTuple<IGalleryQuery, Exact<{
+    query?: IGalleryQueryInput;
+}>>;
+export declare type GalleryQueryHookResult = ReturnType<typeof useGalleryQuery>;
+export declare type GalleryLazyQueryHookResult = ReturnType<typeof useGalleryLazyQuery>;
+export declare type GalleryQueryResult = Apollo.QueryResult<IGalleryQuery, IGalleryQueryVariables>;
+export declare const InstalledExtensionsDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useInstalledExtensionsQuery(baseOptions?: Apollo.QueryHookOptions<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>): Apollo.QueryResult<IInstalledExtensionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useInstalledExtensionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>): Apollo.LazyQueryResultTuple<IInstalledExtensionsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type InstalledExtensionsQueryHookResult = ReturnType<typeof useInstalledExtensionsQuery>;
+export declare type InstalledExtensionsLazyQueryHookResult = ReturnType<typeof useInstalledExtensionsLazyQuery>;
+export declare type InstalledExtensionsQueryResult = Apollo.QueryResult<IInstalledExtensionsQuery, IInstalledExtensionsQueryVariables>;
+export declare const NotificationsDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useNotificationsQuery(baseOptions?: Apollo.QueryHookOptions<INotificationsQuery, INotificationsQueryVariables>): Apollo.QueryResult<INotificationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useNotificationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<INotificationsQuery, INotificationsQueryVariables>): Apollo.LazyQueryResultTuple<INotificationsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare type NotificationsQueryHookResult = ReturnType<typeof useNotificationsQuery>;
+export declare type NotificationsLazyQueryHookResult = ReturnType<typeof useNotificationsLazyQuery>;
+export declare type NotificationsQueryResult = Apollo.QueryResult<INotificationsQuery, INotificationsQueryVariables>;
+export declare const ShowNotificationDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useShowNotificationQuery(baseOptions?: Apollo.QueryHookOptions<IShowNotificationQuery, IShowNotificationQueryVariables>): Apollo.QueryResult<IShowNotificationQuery, Exact<{
+    notification?: INotificationInput;
+}>>;
+export declare function useShowNotificationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IShowNotificationQuery, IShowNotificationQueryVariables>): Apollo.LazyQueryResultTuple<IShowNotificationQuery, Exact<{
+    notification?: INotificationInput;
+}>>;
+export declare type ShowNotificationQueryHookResult = ReturnType<typeof useShowNotificationQuery>;
+export declare type ShowNotificationLazyQueryHookResult = ReturnType<typeof useShowNotificationLazyQuery>;
+export declare type ShowNotificationQueryResult = Apollo.QueryResult<IShowNotificationQuery, IShowNotificationQueryVariables>;
+export declare type ResolverTypeWrapper<T> = Promise<T> | T;
+export declare type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export declare type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
+    fragment: string;
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export declare type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
+    selectionSet: string;
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export declare type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
+export declare type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs> | StitchingResolver<TResult, TParent, TContext, TArgs>;
+export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export declare type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;
+export declare 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 declare type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+export declare type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+export declare type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+export declare type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export declare type NextResolverFn<T> = () => Promise<T>;
+export declare 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 declare type IResolversTypes = {
+    AdminIdeSettings: ResolverTypeWrapper<IAdminIdeSettings>;
+    Int: ResolverTypeWrapper<Scalars['Int']>;
+    Anchor: ResolverTypeWrapper<IAnchor>;
+    AnchorInput: IAnchorInput;
+    AnyObject: ResolverTypeWrapper<Scalars['AnyObject']>;
+    ArgsType: ResolverTypeWrapper<IArgsType>;
+    String: ResolverTypeWrapper<Scalars['String']>;
+    Assets: ResolverTypeWrapper<IAssets>;
+    Author: ResolverTypeWrapper<IAuthor>;
+    BaseExtension: ResolverTypeWrapper<IBaseExtension>;
+    Bundles: ResolverTypeWrapper<IBundles>;
+    CacheControlScope: ICacheControlScope;
+    ClientContainerService: IClientContainerService;
+    CommandHandlerDescriptionType: ResolverTypeWrapper<ICommandHandlerDescriptionType>;
+    CommandType: ResolverTypeWrapper<ICommandType>;
+    CommandsType: ResolverTypeWrapper<ICommandsType>;
+    ContextMenu: ResolverTypeWrapper<IContextMenu>;
+    Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+    ContextMenuInput: IContextMenuInput;
+    Contributes: ResolverTypeWrapper<IContributes>;
+    ContributionAction: ResolverTypeWrapper<IContributionAction>;
+    ContributionActionInput: IContributionActionInput;
+    ContributionActionItem: ResolverTypeWrapper<IContributionActionItem>;
+    ContributionActionRun: ResolverTypeWrapper<IContributionActionRun>;
+    ContributionActionRunInput: IContributionActionRunInput;
+    ContributionActions: ResolverTypeWrapper<IContributionActions>;
+    ContributionView: ResolverTypeWrapper<IContributionView>;
+    ID: ResolverTypeWrapper<Scalars['ID']>;
+    Date: ResolverTypeWrapper<Scalars['Date']>;
+    DateTime: ResolverTypeWrapper<Scalars['DateTime']>;
+    Debugger: ResolverTypeWrapper<IDebugger>;
+    DocSitePage: ResolverTypeWrapper<IDocSitePage>;
+    DocumentFilter: ResolverTypeWrapper<IDocumentFilter>;
+    EmptyResponse: ResolverTypeWrapper<IEmptyResponse>;
+    Engines: ResolverTypeWrapper<IEngines>;
+    Environment: ResolverTypeWrapper<IEnvironment>;
+    EnvironmentPayload: IEnvironmentPayload;
+    EnvironmentSync: IEnvironmentSync;
+    ExtensionColor: ResolverTypeWrapper<IExtensionColor>;
+    ExtensionColorTypes: ResolverTypeWrapper<IExtensionColorTypes>;
+    ExtensionConfiguration: ResolverTypeWrapper<IExtensionConfiguration>;
+    ExtensionConfigurationProperty: ResolverTypeWrapper<IExtensionConfigurationProperty>;
+    ExtensionContributions: ResolverTypeWrapper<IExtensionContributions>;
+    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>;
+    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>;
+    Grammar: ResolverTypeWrapper<IGrammar>;
+    GraphqlCallType: IGraphqlCallType;
+    Hover: never;
+    IActivationRequest: IIActivationRequest;
+    IBehaviorSubject: ResolverTypeWrapper<IIBehaviorSubject>;
+    IBehaviorSubjectValue: ResolverTypeWrapper<IIBehaviorSubjectValue>;
+    IDestinationAnonymousSubject: ResolverTypeWrapper<IIDestinationAnonymousSubject>;
+    IDocumentSelector: ResolverTypeWrapper<IIDocumentSelector>;
+    IModel: ResolverTypeWrapper<IIModel>;
+    IModelInput: IIModelInput;
+    IObservableResult: ResolverTypeWrapper<IIObservableResult>;
+    IResourceUtilizationSettings: never;
+    ISourceAnonymousSubject: ResolverTypeWrapper<IISourceAnonymousSubject>;
+    ISwitchMapOperator: ResolverTypeWrapper<IISwitchMapOperator>;
+    ITextDocumentIdentifier: IResolversTypes['TextDocumentIdentifier'] | IResolversTypes['TextDocumentItem'];
+    IViewComponentData: ResolverTypeWrapper<IIViewComponentData>;
+    IViewComponentDataInput: IIViewComponentDataInput;
+    IWorkspaceRoot: ResolverTypeWrapper<IIWorkspaceRoot>;
+    IWorkspaceRootInput: IIWorkspaceRootInput;
+    InstalledExtension: ResolverTypeWrapper<IInstalledExtension>;
+    JSON: ResolverTypeWrapper<Scalars['JSON']>;
+    JSONObject: ResolverTypeWrapper<Scalars['JSONObject']>;
+    KeyBinding: ResolverTypeWrapper<IKeyBinding>;
+    Localization: ResolverTypeWrapper<ILocalization>;
+    LocalizationTranslation: ResolverTypeWrapper<ILocalizationTranslation>;
+    Location: IResolversTypes['ProvideTextDocumentLocationSignature'];
+    MarkupContent: never;
+    MarkupKind: IMarkupKind;
+    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>;
+    MessageLink: ResolverTypeWrapper<IMessageLink>;
+    MessageLinkInput: IMessageLinkInput;
+    MoleculerServiceName: IMoleculerServiceName;
+    Mutation: ResolverTypeWrapper<{}>;
+    Node: IResolversTypes['RegistryExtension'];
+    Notification: ResolverTypeWrapper<INotification>;
+    NotificationActions: ResolverTypeWrapper<INotificationActions>;
+    NotificationActionsInput: INotificationActionsInput;
+    NotificationChangeEvent: ResolverTypeWrapper<INotificationChangeEvent>;
+    NotificationChangeType: INotificationChangeType;
+    NotificationInput: INotificationInput;
+    NotificationMessage: ResolverTypeWrapper<INotificationMessage>;
+    NotificationMessageInput: INotificationMessageInput;
+    NotificationSeverity: INotificationSeverity;
+    NotificationViewItem: ResolverTypeWrapper<INotificationViewItem>;
+    NotificationViewItemLabelKind: INotificationViewItemLabelKind;
+    NotificationViewItemProgress: ResolverTypeWrapper<INotificationViewItemProgress>;
+    NotificationViewItemProgressState: ResolverTypeWrapper<INotificationViewItemProgressState>;
+    Notifications: ResolverTypeWrapper<INotifications>;
+    Observable: ResolverTypeWrapper<Scalars['Observable']>;
+    OpenDocumentParamsInput: IOpenDocumentParamsInput;
+    OpenDocumentTextParamsInput: IOpenDocumentTextParamsInput;
+    PageInfo: ResolverTypeWrapper<IPageInfo>;
+    Position: ResolverTypeWrapper<IPosition>;
+    PositionInput: IPositionInput;
+    ProcessMonitoring: ResolverTypeWrapper<IProcessMonitoring>;
+    PromptChoiceInput: IPromptChoiceInput;
+    PromptChoiceRun: IPromptChoiceRun;
+    PromptOptionsCancel: IPromptOptionsCancel;
+    PromptOptionsInput: IPromptOptionsInput;
+    ProvideTextDocumentLocationSignature: ResolverTypeWrapper<IProvideTextDocumentLocationSignature>;
+    ProvideTextDocumentLocationSignatureInput: IProvideTextDocumentLocationSignatureInput;
+    Query: ResolverTypeWrapper<{}>;
+    Range: ResolverTypeWrapper<IRange>;
+    RangeInput: IRangeInput;
+    RegistryEntry: ResolverTypeWrapper<IRegistryEntry>;
+    RegistryExtension: ResolverTypeWrapper<IRegistryExtension>;
+    RegistryExtensionConnection: ResolverTypeWrapper<IRegistryExtensionConnection>;
+    RegistryPublisher: ResolverTypeWrapper<IRegistryPublisher>;
+    RegistryPublisherConnection: ResolverTypeWrapper<IRegistryPublisherConnection>;
+    Scripts: ResolverTypeWrapper<IScripts>;
+    Snippet: ResolverTypeWrapper<ISnippet>;
+    Sort: ISort;
+    SortEnum: ISortEnum;
+    Subscription: ResolverTypeWrapper<{}>;
+    TextDocumentIdentifier: ResolverTypeWrapper<ITextDocumentIdentifier>;
+    TextDocumentIdentifierInput: ITextDocumentIdentifierInput;
+    TextDocumentItem: ResolverTypeWrapper<ITextDocumentItem>;
+    TextDocumentItemInput: ITextDocumentItemInput;
+    TextDocumentPositionParams: IResolversTypes['ProvideTextDocumentLocationSignature'];
+    TextDocumentPositionParamsInput: ITextDocumentPositionParamsInput;
+    TextDocumentRegistrationOptions: ResolverTypeWrapper<ITextDocumentRegistrationOptions>;
+    TextDocumentRegistrationOptionsInput: ITextDocumentRegistrationOptionsInput;
+    ThemeLabel: ResolverTypeWrapper<IThemeLabel>;
+    Time: ResolverTypeWrapper<Scalars['Time']>;
+    URI: ResolverTypeWrapper<Scalars['URI']>;
+    URIInput: ResolverTypeWrapper<Scalars['URIInput']>;
+    ViewContainer: ResolverTypeWrapper<IViewContainer>;
+};
+/** Mapping between all available schema types and the resolvers parents */
+export declare type IResolversParentTypes = {
+    AdminIdeSettings: IAdminIdeSettings;
+    Int: Scalars['Int'];
+    Anchor: IAnchor;
+    AnchorInput: IAnchorInput;
+    AnyObject: Scalars['AnyObject'];
+    ArgsType: IArgsType;
+    String: Scalars['String'];
+    Assets: IAssets;
+    Author: IAuthor;
+    BaseExtension: IBaseExtension;
+    Bundles: IBundles;
+    CommandHandlerDescriptionType: ICommandHandlerDescriptionType;
+    CommandType: ICommandType;
+    CommandsType: ICommandsType;
+    ContextMenu: IContextMenu;
+    Boolean: Scalars['Boolean'];
+    ContextMenuInput: IContextMenuInput;
+    Contributes: IContributes;
+    ContributionAction: IContributionAction;
+    ContributionActionInput: IContributionActionInput;
+    ContributionActionItem: IContributionActionItem;
+    ContributionActionRun: IContributionActionRun;
+    ContributionActionRunInput: IContributionActionRunInput;
+    ContributionActions: IContributionActions;
+    ContributionView: IContributionView;
+    ID: Scalars['ID'];
+    Date: Scalars['Date'];
+    DateTime: Scalars['DateTime'];
+    Debugger: IDebugger;
+    DocSitePage: IDocSitePage;
+    DocumentFilter: IDocumentFilter;
+    EmptyResponse: IEmptyResponse;
+    Engines: IEngines;
+    Environment: IEnvironment;
+    EnvironmentPayload: IEnvironmentPayload;
+    ExtensionColor: IExtensionColor;
+    ExtensionColorTypes: IExtensionColorTypes;
+    ExtensionConfiguration: IExtensionConfiguration;
+    ExtensionConfigurationProperty: IExtensionConfigurationProperty;
+    ExtensionContributions: IExtensionContributions;
+    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;
+    GalleryBanner: IGalleryBanner;
+    GalleryExtension: IGalleryExtension;
+    Float: Scalars['Float'];
+    GalleryExtensionAsset: IGalleryExtensionAsset;
+    GalleryExtensionAssets: IGalleryExtensionAssets;
+    GalleryExtensionProperties: IGalleryExtensionProperties;
+    GalleryExtensionResources: IGalleryExtensionResources;
+    GalleryFilter: IGalleryFilter;
+    GalleryPager: IGalleryPager;
+    GalleryQueryInput: IGalleryQueryInput;
+    GeoLocation: IGeoLocation;
+    Grammar: IGrammar;
+    Hover: never;
+    IActivationRequest: IIActivationRequest;
+    IBehaviorSubject: IIBehaviorSubject;
+    IBehaviorSubjectValue: IIBehaviorSubjectValue;
+    IDestinationAnonymousSubject: IIDestinationAnonymousSubject;
+    IDocumentSelector: IIDocumentSelector;
+    IModel: IIModel;
+    IModelInput: IIModelInput;
+    IObservableResult: IIObservableResult;
+    IResourceUtilizationSettings: never;
+    ISourceAnonymousSubject: IISourceAnonymousSubject;
+    ISwitchMapOperator: IISwitchMapOperator;
+    ITextDocumentIdentifier: IResolversParentTypes['TextDocumentIdentifier'] | IResolversParentTypes['TextDocumentItem'];
+    IViewComponentData: IIViewComponentData;
+    IViewComponentDataInput: IIViewComponentDataInput;
+    IWorkspaceRoot: IIWorkspaceRoot;
+    IWorkspaceRootInput: IIWorkspaceRootInput;
+    InstalledExtension: IInstalledExtension;
+    JSON: Scalars['JSON'];
+    JSONObject: Scalars['JSONObject'];
+    KeyBinding: IKeyBinding;
+    Localization: ILocalization;
+    LocalizationTranslation: ILocalizationTranslation;
+    Location: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
+    MarkupContent: never;
+    MenuItem: IMenuItem;
+    MenuItemAction: IMenuItemAction;
+    MenuItemActionContext: IMenuItemActionContext;
+    MenuItemActionDebug: IMenuItemActionDebug;
+    MenuItemActionEditor: IMenuItemActionEditor;
+    MenuItemActionEditorTitle: IMenuItemActionEditorTitle;
+    MenuItemActionScm: IMenuItemActionScm;
+    MenuItemActionScmChange: IMenuItemActionScmChange;
+    MenuItemActionView: IMenuItemActionView;
+    MenuItemInput: IMenuItemInput;
+    Menus: IMenus;
+    MessageLink: IMessageLink;
+    MessageLinkInput: IMessageLinkInput;
+    Mutation: {};
+    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'];
+    OpenDocumentParamsInput: IOpenDocumentParamsInput;
+    OpenDocumentTextParamsInput: IOpenDocumentTextParamsInput;
+    PageInfo: IPageInfo;
+    Position: IPosition;
+    PositionInput: IPositionInput;
+    ProcessMonitoring: IProcessMonitoring;
+    PromptChoiceInput: IPromptChoiceInput;
+    PromptChoiceRun: IPromptChoiceRun;
+    PromptOptionsCancel: IPromptOptionsCancel;
+    PromptOptionsInput: IPromptOptionsInput;
+    ProvideTextDocumentLocationSignature: IProvideTextDocumentLocationSignature;
+    ProvideTextDocumentLocationSignatureInput: IProvideTextDocumentLocationSignatureInput;
+    Query: {};
+    Range: IRange;
+    RangeInput: IRangeInput;
+    RegistryEntry: IRegistryEntry;
+    RegistryExtension: IRegistryExtension;
+    RegistryExtensionConnection: IRegistryExtensionConnection;
+    RegistryPublisher: IRegistryPublisher;
+    RegistryPublisherConnection: IRegistryPublisherConnection;
+    Scripts: IScripts;
+    Snippet: ISnippet;
+    Sort: ISort;
+    Subscription: {};
+    TextDocumentIdentifier: ITextDocumentIdentifier;
+    TextDocumentIdentifierInput: ITextDocumentIdentifierInput;
+    TextDocumentItem: ITextDocumentItem;
+    TextDocumentItemInput: ITextDocumentItemInput;
+    TextDocumentPositionParams: IResolversParentTypes['ProvideTextDocumentLocationSignature'];
+    TextDocumentPositionParamsInput: ITextDocumentPositionParamsInput;
+    TextDocumentRegistrationOptions: ITextDocumentRegistrationOptions;
+    TextDocumentRegistrationOptionsInput: ITextDocumentRegistrationOptionsInput;
+    ThemeLabel: IThemeLabel;
+    Time: Scalars['Time'];
+    URI: Scalars['URI'];
+    URIInput: Scalars['URIInput'];
+    ViewContainer: IViewContainer;
+};
+export declare type ICacheControlDirectiveArgs = {
+    maxAge?: Maybe<Scalars['Int']>;
+    scope?: Maybe<ICacheControlScope>;
+};
+export declare type ICacheControlDirectiveResolver<Result, Parent, ContextType = MyContext, Args = ICacheControlDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+export declare type IAdminIdeSettingsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['AdminIdeSettings'] = IResolversParentTypes['AdminIdeSettings']> = {
+    dummy?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IAnchorResolvers<ContextType = MyContext, 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 declare type IArgsTypeResolvers<ContextType = MyContext, 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 declare type IAssetsResolvers<ContextType = MyContext, 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 declare type IAuthorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Author'] = IResolversParentTypes['Author']> = {
+    name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IBaseExtensionResolvers<ContextType = MyContext, 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 declare type IBundlesResolvers<ContextType = MyContext, 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 declare type ICommandHandlerDescriptionTypeResolvers<ContextType = MyContext, 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 declare type ICommandTypeResolvers<ContextType = MyContext, 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 declare type ICommandsTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['CommandsType'] = IResolversParentTypes['CommandsType']> = {
+    commands?: Resolver<Maybe<Array<Maybe<IResolversTypes['CommandType']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IContextMenuResolvers<ContextType = MyContext, 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 declare type IContributesResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Contributes'] = IResolversParentTypes['Contributes']> = {
+    menus?: Resolver<Maybe<IResolversTypes['Menus']>, ParentType, ContextType>;
+    actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionActions']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IContributionActionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionAction'] = IResolversParentTypes['ContributionAction']> = {
+    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['ContributionActionRun']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IContributionActionItemResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActionItem'] = IResolversParentTypes['ContributionActionItem']> = {
+    label?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IContributionActionRunResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActionRun'] = IResolversParentTypes['ContributionActionRun']> = {
+    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 declare type IContributionActionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionActions'] = IResolversParentTypes['ContributionActions']> = {
+    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['ContributionActionItem']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IContributionViewResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ContributionView'] = IResolversParentTypes['ContributionView']> = {
+    id?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+    name?: Resolver<Maybe<IResolversTypes['String']>, 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 declare type IDebuggerResolvers<ContextType = MyContext, 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 declare type IDocSitePageResolvers<ContextType = MyContext, 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 declare type IDocumentFilterResolvers<ContextType = MyContext, 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 declare type IEmptyResponseResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['EmptyResponse'] = IResolversParentTypes['EmptyResponse']> = {
+    alwaysNil?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IEnginesResolvers<ContextType = MyContext, 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 declare type IEnvironmentResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Environment'] = IResolversParentTypes['Environment']> = {
+    extHostLogsPath?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
+    extensionDevelopmentLocationURI?: Resolver<Maybe<Array<Maybe<IResolversTypes['URI']>>>, ParentType, ContextType>;
+    extensionEnabledProposedApi?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    extensionTestsLocationURI?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
+    isExtensionDevelopment?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    logExtensionHostCommunication?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    logsPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    remoteAuthority?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    sessionId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    sync?: Resolver<Maybe<IResolversTypes['EnvironmentSync']>, ParentType, ContextType>;
+    userDataPath?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    userDataSyncHome?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
+    userDataSyncLogResource?: Resolver<Maybe<IResolversTypes['URI']>, ParentType, ContextType>;
+    webviewCspSource?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    webviewExternalEndpoint?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    webviewResourceRoot?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionColorResolvers<ContextType = MyContext, 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 declare type IExtensionColorTypesResolvers<ContextType = MyContext, 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 declare type IExtensionConfigurationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionConfiguration'] = IResolversParentTypes['ExtensionConfiguration']> = {
+    properties?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionConfigurationPropertyResolvers<ContextType = MyContext, 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 declare type IExtensionContributionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionContributions'] = IResolversParentTypes['ExtensionContributions']> = {
+    actions?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionActions']>>>, ParentType, ContextType>;
+    commands?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionActions']>>>, 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 declare type IExtensionIdentifierResolvers<ContextType = MyContext, 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 declare type IExtensionInstanceResolvers<ContextType = MyContext, 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 declare type IExtensionJsonValidationResolvers<ContextType = MyContext, 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 declare type IExtensionLanguageResolvers<ContextType = MyContext, 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 declare type IExtensionManifestResolvers<ContextType = MyContext, 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>;
+    readme?: 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>;
+    tags?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    url?: 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 declare type IExtensionManifestBugsResolvers<ContextType = MyContext, 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 declare type IExtensionManifestRepositoryResolvers<ContextType = MyContext, 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 declare type IExtensionPackageTypeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionPackageType'] = IResolversParentTypes['ExtensionPackageType']> = {
+    type?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionRegistryResolvers<ContextType = MyContext, 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 declare type IExtensionRegistryCreateExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryCreateExtensionResult'] = IResolversParentTypes['ExtensionRegistryCreateExtensionResult']> = {
+    extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionRegistryPublishExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryPublishExtensionResult'] = IResolversParentTypes['ExtensionRegistryPublishExtensionResult']> = {
+    extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionRegistryUpdateExtensionResultResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ExtensionRegistryUpdateExtensionResult'] = IResolversParentTypes['ExtensionRegistryUpdateExtensionResult']> = {
+    extension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IExtensionReleaseResolvers<ContextType = MyContext, 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 declare type IFieldErrorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['FieldError'] = IResolversParentTypes['FieldError']> = {
+    field?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    message?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IGalleryBannerResolvers<ContextType = MyContext, 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 declare type IGalleryExtensionResolvers<ContextType = MyContext, 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 declare type IGalleryExtensionAssetResolvers<ContextType = MyContext, 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 declare type IGalleryExtensionAssetsResolvers<ContextType = MyContext, 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 declare type IGalleryExtensionPropertiesResolvers<ContextType = MyContext, 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 declare type IGalleryExtensionResourcesResolvers<ContextType = MyContext, 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 declare type IGalleryPagerResolvers<ContextType = MyContext, 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 declare type IGeoLocationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['GeoLocation'] = IResolversParentTypes['GeoLocation']> = {
+    coordinates?: Resolver<Maybe<Array<Maybe<IResolversTypes['Float']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IGrammarResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Grammar'] = IResolversParentTypes['Grammar']> = {
+    language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IHoverResolvers<ContextType = MyContext, 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 declare type IIBehaviorSubjectResolvers<ContextType = MyContext, 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 declare type IIBehaviorSubjectValueResolvers<ContextType = MyContext, 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 declare type IIDestinationAnonymousSubjectResolvers<ContextType = MyContext, 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 declare type IIDocumentSelectorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IDocumentSelector'] = IResolversParentTypes['IDocumentSelector']> = {
+    documentSelector?: Resolver<Maybe<IResolversTypes['JSON']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IIModelResolvers<ContextType = MyContext, 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 declare type IIObservableResultResolvers<ContextType = MyContext, 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 declare type IIResourceUtilizationSettingsResolvers<ContextType = MyContext, 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 declare type IISourceAnonymousSubjectResolvers<ContextType = MyContext, 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 declare type IISwitchMapOperatorResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['ISwitchMapOperator'] = IResolversParentTypes['ISwitchMapOperator']> = {
+    project?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IITextDocumentIdentifierResolvers<ContextType = MyContext, 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 declare type IIViewComponentDataResolvers<ContextType = MyContext, 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 declare type IIWorkspaceRootResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['IWorkspaceRoot'] = IResolversParentTypes['IWorkspaceRoot']> = {
+    url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IInstalledExtensionResolvers<ContextType = MyContext, 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 interface IJsonScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSON'], any> {
+    name: 'JSON';
+}
+export interface IJsonObjectScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['JSONObject'], any> {
+    name: 'JSONObject';
+}
+export declare type IKeyBindingResolvers<ContextType = MyContext, 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 declare type ILocalizationResolvers<ContextType = MyContext, 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 declare type ILocalizationTranslationResolvers<ContextType = MyContext, 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 declare type ILocationResolvers<ContextType = MyContext, 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 declare type IMarkupContentResolvers<ContextType = MyContext, 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 declare type IMenuItemResolvers<ContextType = MyContext, 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['ContributionActionRun']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IMenuItemActionResolvers<ContextType = MyContext, 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 declare type IMenuItemActionContextResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionContext'] = IResolversParentTypes['MenuItemActionContext']> = {
+    context?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IMenuItemActionDebugResolvers<ContextType = MyContext, 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 declare type IMenuItemActionEditorResolvers<ContextType = MyContext, 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 declare type IMenuItemActionEditorTitleResolvers<ContextType = MyContext, 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 declare type IMenuItemActionScmResolvers<ContextType = MyContext, 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 declare type IMenuItemActionScmChangeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['MenuItemActionScmChange'] = IResolversParentTypes['MenuItemActionScmChange']> = {
+    title?: Resolver<Maybe<Array<Maybe<IResolversTypes['MenuItemAction']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IMenuItemActionViewResolvers<ContextType = MyContext, 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 declare type IMenusResolvers<ContextType = MyContext, 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 declare type IMessageLinkResolvers<ContextType = MyContext, 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 declare type IMutationResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+    activate?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationActivateArgs, 'request'>>;
+    addNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationAddNotificationArgs, 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>>;
+    createExtension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType, RequireFields<IMutationCreateExtensionArgs, 'publisher' | 'name'>>;
+    definitionDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationDefinitionDefinitionArgs, never>>;
+    deleteExtension?: Resolver<IResolversTypes['EmptyResponse'], ParentType, ContextType, RequireFields<IMutationDeleteExtensionArgs, 'extension'>>;
+    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>;
+    handler?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationHandlerArgs, never>>;
+    hideContextMenu?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+    hoverProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationHoverProviderDefinitionArgs, never>>;
+    install?: Resolver<Maybe<IResolversTypes['ExtensionIdentifier']>, ParentType, ContextType, RequireFields<IMutationInstallArgs, 'vsix'>>;
+    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>>;
+    openLanguageDocument?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationOpenLanguageDocumentArgs, never>>;
+    publishExtension?: Resolver<IResolversTypes['ExtensionRegistryPublishExtensionResult'], ParentType, ContextType, RequireFields<IMutationPublishExtensionArgs, 'extensionID' | 'manifest' | 'force'>>;
+    referenceProviderDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationReferenceProviderDefinitionArgs, never>>;
+    removeExtension?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRemoveExtensionArgs, 'id'>>;
+    renameDefinition?: Resolver<Maybe<IResolversTypes['Observable']>, ParentType, ContextType, RequireFields<IMutationRenameDefinitionArgs, never>>;
+    runMenuAction?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationRunMenuActionArgs, never>>;
+    showContextMenu?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationShowContextMenuArgs, never>>;
+    startExtensionHost?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationStartExtensionHostArgs, never>>;
+    updateExtension?: Resolver<IResolversTypes['RegistryExtension'], ParentType, ContextType, RequireFields<IMutationUpdateExtensionArgs, 'extension'>>;
+    updateModel?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IMutationUpdateModelArgs, never>>;
+};
+export declare type INodeResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Node'] = IResolversParentTypes['Node']> = {
+    __resolveType: TypeResolveFn<'RegistryExtension', ParentType, ContextType>;
+    id?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+};
+export declare type INotificationResolvers<ContextType = MyContext, 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 declare type INotificationActionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationActions'] = IResolversParentTypes['NotificationActions']> = {
+    primary?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionAction']>>>, ParentType, ContextType>;
+    secondary?: Resolver<Maybe<Array<Maybe<IResolversTypes['ContributionAction']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type INotificationChangeEventResolvers<ContextType = MyContext, 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 declare type INotificationMessageResolvers<ContextType = MyContext, 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 declare type INotificationViewItemResolvers<ContextType = MyContext, 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 declare type INotificationViewItemProgressResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['NotificationViewItemProgress'] = IResolversParentTypes['NotificationViewItemProgress']> = {
+    state?: Resolver<Maybe<IResolversTypes['NotificationViewItemProgressState']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type INotificationViewItemProgressStateResolvers<ContextType = MyContext, 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 declare type INotificationsResolvers<ContextType = MyContext, 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 declare type IPageInfoResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['PageInfo'] = IResolversParentTypes['PageInfo']> = {
+    hasNextPage?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IPositionResolvers<ContextType = MyContext, 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 declare type IProcessMonitoringResolvers<ContextType = MyContext, 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 declare type IProvideTextDocumentLocationSignatureResolvers<ContextType = MyContext, 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 declare type IQueryResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+    contextMenu?: Resolver<Maybe<IResolversTypes['ContextMenu']>, ParentType, ContextType>;
+    docSitePage?: Resolver<Maybe<IResolversTypes['DocSitePage']>, ParentType, ContextType, RequireFields<IQueryDocSitePageArgs, 'path'>>;
+    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'>>;
+    gallery?: Resolver<Maybe<IResolversTypes['GalleryPager']>, ParentType, ContextType, RequireFields<IQueryGalleryArgs, never>>;
+    galleryExtension?: Resolver<Maybe<IResolversTypes['GalleryExtension']>, ParentType, ContextType, RequireFields<IQueryGalleryExtensionArgs, 'extensionID'>>;
+    installed?: Resolver<Maybe<Array<Maybe<IResolversTypes['InstalledExtension']>>>, ParentType, ContextType>;
+    instances?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionInstance']>>>, ParentType, ContextType>;
+    node?: Resolver<Maybe<IResolversTypes['Node']>, ParentType, ContextType, RequireFields<IQueryNodeArgs, 'id'>>;
+    notifications?: Resolver<Maybe<IResolversTypes['Notifications']>, ParentType, ContextType>;
+    registerProvider?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IQueryRegisterProviderArgs, never>>;
+    releases?: Resolver<Maybe<Array<Maybe<IResolversTypes['ExtensionRelease']>>>, ParentType, ContextType, RequireFields<IQueryReleasesArgs, 'extensionID'>>;
+    showNotification?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType, RequireFields<IQueryShowNotificationArgs, never>>;
+};
+export declare type IRangeResolvers<ContextType = MyContext, 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 declare type IRegistryEntryResolvers<ContextType = MyContext, 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 declare type IRegistryExtensionResolvers<ContextType = MyContext, 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 declare type IRegistryExtensionConnectionResolvers<ContextType = MyContext, 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 declare type IRegistryPublisherResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['RegistryPublisher'] = IResolversParentTypes['RegistryPublisher']> = {
+    UserId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IRegistryPublisherConnectionResolvers<ContextType = MyContext, 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 declare type IScriptsResolvers<ContextType = MyContext, 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 declare type ISnippetResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Snippet'] = IResolversParentTypes['Snippet']> = {
+    language?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type ISubscriptionResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
+    dummy?: SubscriptionResolver<Maybe<IResolversTypes['Int']>, "dummy", ParentType, ContextType>;
+};
+export declare type ITextDocumentIdentifierResolvers<ContextType = MyContext, 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 declare type ITextDocumentItemResolvers<ContextType = MyContext, 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 declare type ITextDocumentPositionParamsResolvers<ContextType = MyContext, 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 declare type ITextDocumentRegistrationOptionsResolvers<ContextType = MyContext, ParentType extends IResolversParentTypes['TextDocumentRegistrationOptions'] = IResolversParentTypes['TextDocumentRegistrationOptions']> = {
+    documentSelector?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export declare type IThemeLabelResolvers<ContextType = MyContext, 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 interface IUriScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URI'], any> {
+    name: 'URI';
+}
+export interface IUriInputScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['URIInput'], any> {
+    name: 'URIInput';
+}
+export declare type IViewContainerResolvers<ContextType = MyContext, 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 declare type IResolvers<ContextType = MyContext> = {
+    AdminIdeSettings?: IAdminIdeSettingsResolvers<ContextType>;
+    Anchor?: IAnchorResolvers<ContextType>;
+    AnyObject?: GraphQLScalarType;
+    ArgsType?: IArgsTypeResolvers<ContextType>;
+    Assets?: IAssetsResolvers<ContextType>;
+    Author?: IAuthorResolvers<ContextType>;
+    BaseExtension?: IBaseExtensionResolvers<ContextType>;
+    Bundles?: IBundlesResolvers<ContextType>;
+    CommandHandlerDescriptionType?: ICommandHandlerDescriptionTypeResolvers<ContextType>;
+    CommandType?: ICommandTypeResolvers<ContextType>;
+    CommandsType?: ICommandsTypeResolvers<ContextType>;
+    ContextMenu?: IContextMenuResolvers<ContextType>;
+    Contributes?: IContributesResolvers<ContextType>;
+    ContributionAction?: IContributionActionResolvers<ContextType>;
+    ContributionActionItem?: IContributionActionItemResolvers<ContextType>;
+    ContributionActionRun?: IContributionActionRunResolvers<ContextType>;
+    ContributionActions?: IContributionActionsResolvers<ContextType>;
+    ContributionView?: IContributionViewResolvers<ContextType>;
+    Date?: GraphQLScalarType;
+    DateTime?: GraphQLScalarType;
+    Debugger?: IDebuggerResolvers<ContextType>;
+    DocSitePage?: IDocSitePageResolvers<ContextType>;
+    DocumentFilter?: IDocumentFilterResolvers<ContextType>;
+    EmptyResponse?: IEmptyResponseResolvers<ContextType>;
+    Engines?: IEnginesResolvers<ContextType>;
+    Environment?: IEnvironmentResolvers<ContextType>;
+    ExtensionColor?: IExtensionColorResolvers<ContextType>;
+    ExtensionColorTypes?: IExtensionColorTypesResolvers<ContextType>;
+    ExtensionConfiguration?: IExtensionConfigurationResolvers<ContextType>;
+    ExtensionConfigurationProperty?: IExtensionConfigurationPropertyResolvers<ContextType>;
+    ExtensionContributions?: IExtensionContributionsResolvers<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>;
+    GalleryBanner?: IGalleryBannerResolvers<ContextType>;
+    GalleryExtension?: IGalleryExtensionResolvers<ContextType>;
+    GalleryExtensionAsset?: IGalleryExtensionAssetResolvers<ContextType>;
+    GalleryExtensionAssets?: IGalleryExtensionAssetsResolvers<ContextType>;
+    GalleryExtensionProperties?: IGalleryExtensionPropertiesResolvers<ContextType>;
+    GalleryExtensionResources?: IGalleryExtensionResourcesResolvers<ContextType>;
+    GalleryPager?: IGalleryPagerResolvers<ContextType>;
+    GeoLocation?: IGeoLocationResolvers<ContextType>;
+    Grammar?: IGrammarResolvers<ContextType>;
+    Hover?: IHoverResolvers<ContextType>;
+    IBehaviorSubject?: IIBehaviorSubjectResolvers<ContextType>;
+    IBehaviorSubjectValue?: IIBehaviorSubjectValueResolvers<ContextType>;
+    IDestinationAnonymousSubject?: IIDestinationAnonymousSubjectResolvers<ContextType>;
+    IDocumentSelector?: IIDocumentSelectorResolvers<ContextType>;
+    IModel?: IIModelResolvers<ContextType>;
+    IObservableResult?: IIObservableResultResolvers<ContextType>;
+    IResourceUtilizationSettings?: IIResourceUtilizationSettingsResolvers<ContextType>;
+    ISourceAnonymousSubject?: IISourceAnonymousSubjectResolvers<ContextType>;
+    ISwitchMapOperator?: IISwitchMapOperatorResolvers<ContextType>;
+    ITextDocumentIdentifier?: IITextDocumentIdentifierResolvers<ContextType>;
+    IViewComponentData?: IIViewComponentDataResolvers<ContextType>;
+    IWorkspaceRoot?: IIWorkspaceRootResolvers<ContextType>;
+    InstalledExtension?: IInstalledExtensionResolvers<ContextType>;
+    JSON?: GraphQLScalarType;
+    JSONObject?: GraphQLScalarType;
+    KeyBinding?: IKeyBindingResolvers<ContextType>;
+    Localization?: ILocalizationResolvers<ContextType>;
+    LocalizationTranslation?: ILocalizationTranslationResolvers<ContextType>;
+    Location?: ILocationResolvers<ContextType>;
+    MarkupContent?: IMarkupContentResolvers<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>;
+    MessageLink?: IMessageLinkResolvers<ContextType>;
+    Mutation?: IMutationResolvers<ContextType>;
+    Node?: INodeResolvers<ContextType>;
+    Notification?: INotificationResolvers<ContextType>;
+    NotificationActions?: INotificationActionsResolvers<ContextType>;
+    NotificationChangeEvent?: INotificationChangeEventResolvers<ContextType>;
+    NotificationMessage?: INotificationMessageResolvers<ContextType>;
+    NotificationViewItem?: INotificationViewItemResolvers<ContextType>;
+    NotificationViewItemProgress?: INotificationViewItemProgressResolvers<ContextType>;
+    NotificationViewItemProgressState?: INotificationViewItemProgressStateResolvers<ContextType>;
+    Notifications?: INotificationsResolvers<ContextType>;
+    Observable?: GraphQLScalarType;
+    PageInfo?: IPageInfoResolvers<ContextType>;
+    Position?: IPositionResolvers<ContextType>;
+    ProcessMonitoring?: IProcessMonitoringResolvers<ContextType>;
+    ProvideTextDocumentLocationSignature?: IProvideTextDocumentLocationSignatureResolvers<ContextType>;
+    Query?: IQueryResolvers<ContextType>;
+    Range?: IRangeResolvers<ContextType>;
+    RegistryEntry?: IRegistryEntryResolvers<ContextType>;
+    RegistryExtension?: IRegistryExtensionResolvers<ContextType>;
+    RegistryExtensionConnection?: IRegistryExtensionConnectionResolvers<ContextType>;
+    RegistryPublisher?: IRegistryPublisherResolvers<ContextType>;
+    RegistryPublisherConnection?: IRegistryPublisherConnectionResolvers<ContextType>;
+    Scripts?: IScriptsResolvers<ContextType>;
+    Snippet?: ISnippetResolvers<ContextType>;
+    Subscription?: ISubscriptionResolvers<ContextType>;
+    TextDocumentIdentifier?: ITextDocumentIdentifierResolvers<ContextType>;
+    TextDocumentItem?: ITextDocumentItemResolvers<ContextType>;
+    TextDocumentPositionParams?: ITextDocumentPositionParamsResolvers<ContextType>;
+    TextDocumentRegistrationOptions?: ITextDocumentRegistrationOptionsResolvers<ContextType>;
+    ThemeLabel?: IThemeLabelResolvers<ContextType>;
+    Time?: GraphQLScalarType;
+    URI?: GraphQLScalarType;
+    URIInput?: GraphQLScalarType;
+    ViewContainer?: IViewContainerResolvers<ContextType>;
+};
+export declare type IDirectiveResolvers<ContextType = MyContext> = {
+    cacheControl?: ICacheControlDirectiveResolver<any, any, ContextType>;
+};