@adminide-stack/marketplace-module-server 5.0.1-alpha.0 → 5.0.1-alpha.8

package/lib/model.d.ts

@@ -0,0 +1,981 @@
+export type Maybe<T> = T | null;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    AnyObject: any;
+    JSON: any;
+    JSONObject: any;
+};
+export type ActionItem = {
+    __typename?: "ActionItem";
+    label?: Maybe<Scalars["String"]>;
+    description?: Maybe<Scalars["String"]>;
+};
+export type Actions = {
+    __typename?: "Actions";
+    id?: Maybe<Scalars["String"]>;
+    command?: Maybe<Scalars["String"]>;
+    title?: Maybe<Scalars["String"]>;
+    category?: Maybe<Scalars["String"]>;
+    actionItem?: Maybe<ActionItem>;
+};
+export type Assets = {
+    __typename?: "Assets";
+    Type?: Maybe<Scalars["String"]>;
+    Content?: Maybe<Scalars["String"]>;
+};
+export type Author = {
+    __typename?: "Author";
+    name?: Maybe<Scalars["String"]>;
+};
+export type Bundles = {
+    __typename?: "Bundles";
+    server?: Maybe<Scalars["String"]>;
+    browser?: Maybe<Scalars["String"]>;
+};
+/** @deprecated use IExtensionContributions */
+export type Contributes = {
+    __typename?: "Contributes";
+    menus?: Maybe<Menus>;
+    actions?: Maybe<Array<Maybe<Actions>>>;
+};
+/**  A CDECode product documentation page. */
+export type DocSitePage = {
+    __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 type EmptyResponse = {
+    __typename?: "EmptyResponse";
+    alwaysNil?: Maybe<Scalars["String"]>;
+};
+export type Engines = {
+    __typename?: "Engines";
+    node?: Maybe<Scalars["String"]>;
+    vscode?: Maybe<Scalars["String"]>;
+};
+export type Extension = {
+    __typename?: "Extension";
+    type?: Maybe<Scalars["String"]>;
+};
+export type ExtensionManifest = {
+    __typename?: "ExtensionManifest";
+    /**  The name of the extension - should be all lowercase with no spaces  */
+    name: Scalars["String"];
+    /**  SemVer compatible version.  */
+    version: Scalars["String"];
+    /**  The entry point to your extension  */
+    main?: Maybe<Scalars["String"]>;
+    type?: 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<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<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: 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["String"]>;
+    /**  Any development Node.js dependencies your extension needs. Exactly the same as npm's devDependencies.  */
+    devDependencies?: Maybe<Scalars["String"]>;
+    /**  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"]>;
+    assets?: Maybe<Array<Maybe<Assets>>>;
+    /**  Exactly the same as npm's scripts but with extra VS Code specific fields such as vscode:prepublish or vscode:uninstall.  */
+    scripts?: Maybe<Scripts>;
+    bundles?: Maybe<Bundles>;
+    extension?: Maybe<Extension>;
+    /**  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: Engines;
+    /**  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<Author>;
+    /**  Helps format the Marketplace header to match your icon. See details below.  */
+    galleryBanner?: Maybe<GalleryBanner>;
+    /**  An array of the activation events for this extension.  */
+    activationEvents?: Maybe<Array<Maybe<Scalars["String"]>>>;
+    /**  An object describing the extension's contributions.  */
+    contributes?: Maybe<Contributes>;
+    /**  The path to the icon of at least 128x128 pixels (256x256 for Retina screens).  */
+    icon?: Maybe<Scalars["String"]>;
+    /** 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<ExtensionManifestBugs>;
+    /** Any development Node.js repository location of your extension.
+     * @example
+     *   "repository": {
+     *        "type": "git",
+     *        "url": "https://github.com/Microsoft/vscode-wordcount.git"
+     *    }
+     */
+    repository?: Maybe<ExtensionManifestRepository>;
+    /** To enable proposed Api's */
+    enableProposedApi?: Maybe<Scalars["Boolean"]>;
+};
+export type ExtensionManifestBugs = {
+    __typename?: "ExtensionManifestBugs";
+    url?: Maybe<Scalars["String"]>;
+    email?: Maybe<Scalars["String"]>;
+};
+export type ExtensionManifestRepository = {
+    __typename?: "ExtensionManifestRepository";
+    type?: Maybe<Scalars["String"]>;
+    url?: Maybe<Scalars["String"]>;
+};
+export type ExtensionRegistry = {
+    __typename?: "ExtensionRegistry";
+    /** 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: RegistryExtensionConnection;
+    /**  List of extension releases  */
+    releases?: Maybe<Array<Maybe<ExtensionRelease>>>;
+    /**  A list of publishers with at least 1 extension in the registry.  */
+    publishers: RegistryPublisherConnection;
+    /**  A list of publishers that the viewer may publish extensions as.  */
+    viewerPublishers: Array<RegistryPublisher>;
+    /** The extension ID prefix for extensions that are published in the local extension registry. This is the
+     * hostname ( and port, if non-default HTTP/HTTPS) of the CDEBase "appURL" site configuration property.
+     *
+     * It is null if extensions published on this CDEBase site do not have an extension ID prefix.
+     *
+     * Examples: "cdebase.example.com/", "cdebase.example.com:1234/"
+     */
+    localExtensionIDPrefix?: Maybe<Scalars["String"]>;
+};
+export type ExtensionRegistryExtensionsArgs = {
+    first?: Maybe<Scalars["Int"]>;
+    query?: Maybe<Scalars["String"]>;
+    local: Scalars["Boolean"];
+    remote: Scalars["Boolean"];
+    includeWIP: Scalars["Boolean"];
+};
+export type ExtensionRegistryReleasesArgs = {
+    extensionID: Scalars["String"];
+};
+export type ExtensionRegistryPublishersArgs = {
+    first?: Maybe<Scalars["Int"]>;
+};
+/**  The result of Mutation.extensionRegistry.createExtension. */
+export type ExtensionRegistryCreateExtensionResult = {
+    __typename?: "ExtensionRegistryCreateExtensionResult";
+    /**  The newly created extension. */
+    extension: RegistryExtension;
+};
+/**  The result of Mutation.extensionRegistry.publishExtension. */
+export type ExtensionRegistryPublishExtensionResult = {
+    __typename?: "ExtensionRegistryPublishExtensionResult";
+    /**  The extension that was just published. */
+    extension: RegistryExtension;
+};
+/**  The result of Mutation.extensionRegistry.updateExtension. */
+export type ExtensionRegistryUpdateExtensionResult = {
+    __typename?: "ExtensionRegistryUpdateExtensionResult";
+    /**  The newly updated extension. */
+    extension: RegistryExtension;
+};
+export type ExtensionRelease = {
+    __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 type FieldError = {
+    __typename?: "FieldError";
+    field: Scalars["String"];
+    message: Scalars["String"];
+};
+export type GalleryBanner = {
+    __typename?: "GalleryBanner";
+    color?: Maybe<Scalars["String"]>;
+    theme?: Maybe<Scalars["String"]>;
+};
+export type Idebugger = {
+    __typename?: "IDebugger";
+    label?: Maybe<Scalars["String"]>;
+    type: Scalars["String"];
+    runtime?: Maybe<Scalars["String"]>;
+};
+export type IextensionColor = {
+    __typename?: "IExtensionColor";
+    id: Scalars["ID"];
+    description?: Maybe<Scalars["String"]>;
+    defaults?: Maybe<IextensionColorTypes>;
+};
+export type IextensionColorTypes = {
+    __typename?: "IExtensionColorTypes";
+    light?: Maybe<Scalars["String"]>;
+    dark?: Maybe<Scalars["String"]>;
+    highContrast?: Maybe<Scalars["String"]>;
+};
+export type IextensionConfiguration = {
+    __typename?: "IExtensionConfiguration";
+    properties?: Maybe<Scalars["JSON"]>;
+};
+export type IextensionConfigurationProperty = {
+    __typename?: "IExtensionConfigurationProperty";
+    description?: Maybe<Scalars["String"]>;
+    type?: Maybe<Array<Maybe<Scalars["String"]>>>;
+    defaults?: Maybe<Scalars["JSON"]>;
+};
+export type IextensionContributions = {
+    __typename?: "IExtensionContributions";
+    /** @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<Actions>>>;
+    /** @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<Menus>;
+    /** @title contributes.snippets
+     * @description Contribute snippets for a specific language. The language
+     * attribute is the language identifier and the path is the relative path to the
+     * snippet file, which defines snippets in the VS Code snippet format.
+     *
+     * @example
+     *
+     * ```json
+     * "contributes": {
+     *     "snippets": [{
+     *         "language": "go",
+     *         "path": "./snippets/go.json"
+     *     }]
+     * }
+     * ```
+     */
+    snippets?: Maybe<Array<Maybe<Isnippet>>>;
+    /** @title contributes.themes
+     * @description Contribute a TextMate theme to VS Code. You must specify a label,
+     * whether the theme is a dark theme or a light theme (such that the rest of VS
+     * Code changes to match your theme) and the path to the file (XML plist format).
+     *
+     * @example
+     *    ```json
+     *    "contributes": {
+     *        "themes": [{
+     *            "label": "Monokai",
+     *            "uiTheme": "vs-dark",
+     *            "path": "./themes/Monokai.tmTheme"
+     *        }]
+     *    }
+     *    ```
+     */
+    themes?: Maybe<Array<Maybe<IthemeLabel>>>;
+    iconThemes?: Maybe<Array<Maybe<IthemeLabel>>>;
+    /**  @title contributes.viewsContainers
+     *  @description Contribute a view container into which Custom views can be
+     * contributed. You must specify an identifier, title, and an icon for the view
+     * container. At present, you can contribute them to the Activity Bar
+     * (activitybar) only. Below example shows how the Package Explorer view
+     * container is contributed to the Activity Bar and how views are contributed to it.
+     *
+     *  @example
+     *     ```json
+     *     "contributes": {
+     *             "viewsContainers": {
+     *                 "activitybar": [
+     *                     {
+     *                         "id": "package-explorer",
+     *                         "title": "Package Explorer",
+     *                         "icon": "resources/package-explorer.svg"
+     *                     }
+     *                 ]
+     *             },
+     *             "views": {
+     *                 "package-explorer": [
+     *                     {
+     *                         "id": "package-dependencies",
+     *                         "name": "Dependencies"
+     *                     },
+     *                     {
+     *                         "id": "package-outline",
+     *                         "name": "Outline"
+     *                     }
+     *                 ]
+     *             }
+     *     }
+     * ```
+     */
+    viewsContainers?: Maybe<Scalars["JSON"]>;
+    /** @title contributes.viewsContainers
+     * @description Contribute a view container into which Custom views can be
+     * contributed. You must specify an identifier, title, and an icon for the view
+     * container. At present, you can contribute them to the Activity Bar
+     * (activitybar) only. Below example shows how the Package Explorer view
+     * container is contributed to the Activity Bar and how views are contributed to it.
+     *
+     * @example
+     * ```json
+     *    "contributes": {
+     *            "viewsContainers": {
+     *                "activitybar": [
+     *                    {
+     *                        "id": "package-explorer",
+     *                        "title": "Package Explorer",
+     *                        "icon": "resources/package-explorer.svg"
+     *                    }
+     *                ]
+     *            },
+     *            "views": {
+     *                "package-explorer": [
+     *                    {
+     *                        "id": "package-dependencies",
+     *                        "name": "Dependencies"
+     *                    },
+     *                    {
+     *                        "id": "package-outline",
+     *                        "name": "Outline"
+     *                    }
+     *                ]
+     *            }
+     *    }
+     * ```
+     */
+    views?: Maybe<Scalars["JSON"]>;
+    /** @title contributes.colors
+     * @description Contributes new themable colors. These colors can be used by the
+     * extension in editor decorators and in the status bar. Once defined, users can
+     * customize the color in the workspace.colorCustomization setting and user
+     * themes can set the color value.
+     *
+     * @example
+     * ```json
+     *    "contributes": {
+     *      "colors": [{
+     *          "id": "superstatus.error",
+     *          "description": "Color for error message in the status bar.",
+     *          "defaults": {
+     *              "dark": "errorForeground",
+     *              "light": "errorForeground",
+     *              "highContrast": "#010203"
+     *          }
+     *      }]
+     *    }
+     * ```
+     * Color default values can be defined for light, dark and high contrast theme
+     * and can either be a reference to an existing color or a Color Hex Value.
+     */
+    colors?: Maybe<Array<Maybe<IextensionColor>>>;
+    localizations?: Maybe<Array<Maybe<Ilocalization>>>;
+};
+export type IextensionJsonvalidation = {
+    __typename?: "IExtensionJSONValidation";
+    fileMatch?: Maybe<Scalars["String"]>;
+    url?: Maybe<Scalars["String"]>;
+};
+export declare enum IextensionKind {
+    Ui = "ui",
+    Workspace = "workspace"
+}
+export type IextensionLanguage = {
+    __typename?: "IExtensionLanguage";
+    id: Scalars["ID"];
+    extensions?: Maybe<Array<Maybe<Scalars["String"]>>>;
+    aliases?: Maybe<Array<Maybe<Scalars["String"]>>>;
+};
+export type Igrammar = {
+    __typename?: "IGrammar";
+    language?: Maybe<Scalars["String"]>;
+};
+export type IkeyBinding = {
+    __typename?: "IKeyBinding";
+    command: Scalars["String"];
+    key: Scalars["String"];
+    when?: Maybe<Scalars["String"]>;
+    mac?: Maybe<Scalars["String"]>;
+    linux?: Maybe<Scalars["String"]>;
+    win?: Maybe<Scalars["String"]>;
+};
+export type Ilocalization = {
+    __typename?: "ILocalization";
+    languageId: Scalars["String"];
+    languageName?: Maybe<Scalars["String"]>;
+    localizedLanguageName?: Maybe<Scalars["String"]>;
+    translations: Array<Maybe<Ilocalization_Itranslation>>;
+    minimalTranslations?: Maybe<Scalars["JSON"]>;
+};
+export type Ilocalization_Itranslation = {
+    __typename?: "ILocalization_ITranslation";
+    id: Scalars["ID"];
+    path?: Maybe<Scalars["String"]>;
+};
+export type Isnippet = {
+    __typename?: "ISnippet";
+    language?: Maybe<Scalars["String"]>;
+};
+export type IthemeLabel = {
+    __typename?: "IThemeLabel";
+    label?: Maybe<Scalars["String"]>;
+    uiTheme?: Maybe<Scalars["String"]>;
+    path?: Maybe<Scalars["String"]>;
+};
+export type Iuser = {
+    __typename?: "User";
+    username?: Maybe<Scalars["String"]>;
+};
+export type Iview = {
+    __typename?: "IView";
+    id: Scalars["ID"];
+    name?: Maybe<Scalars["String"]>;
+};
+export type IviewContainer = {
+    __typename?: "IViewContainer";
+    id: Scalars["ID"];
+    title?: Maybe<Scalars["String"]>;
+};
+export declare enum MenuId {
+    CommandPalette = "CommandPalette",
+    DebugBreakpointsContext = "DebugBreakpointsContext",
+    DebugCallStackContext = "DebugCallStackContext",
+    DebugConsoleContext = "DebugConsoleContext",
+    DebugVariablesContext = "DebugVariablesContext",
+    DebugWatchContext = "DebugWatchContext",
+    DebugTooBar = "DebugTooBar",
+    EditorContext = "EditorContext",
+    EditorTitle = "EditorTitle",
+    EditorTitleContext = "EditorTitleContext",
+    EmptyEditorGroupContext = "EmptyEditorGroupContext",
+    ExplorerContext = "ExplorerContext",
+    MenubarAppearanceMenu = "MenubarAppearanceMenu",
+    MenubarDebugMenu = "MenubarDebugMenu",
+    MenubarEditMenu = "MenubarEditMenu",
+    MenubarFileMenu = "MenubarFileMenu",
+    MenubarGoMenu = "MenubarGoMenu",
+    MenubarNewBreakpointMenu = "MenubarNewBreakpointMenu",
+    MenubarPreferencesMenu = "MenubarPreferencesMenu",
+    MenubarRecentMenu = "MenubarRecentMenu",
+    MenubarSelectionMenu = "MenubarSelectionMenu",
+    MenubarSwitchEditorMenu = "MenubarSwitchEditorMenu",
+    MenubarSwitchGroupMenu = "MenubarSwitchGroupMenu",
+    MenubarTerminalMenu = "MenubarTerminalMenu",
+    MenubarViewMenu = "MenubarViewMenu",
+    OpenEditorContext = "OpenEditorContext",
+    ProblemsPanelContext = "ProblemsPanelContext",
+    ScmchangeContext = "SCMChangeContext",
+    ScmresourceContext = "SCMResourceContext",
+    ScmresourceGroupContext = "SCMResourceGroupContext",
+    ScmresourceControl = "SCMResourceControl",
+    Scmtitle = "SCMTitle",
+    SearchContext = "SearchContext",
+    StatusBarWindowIndicatorMenu = "StatusBarWindowIndicatorMenu",
+    TouchBarContext = "TouchBarContext",
+    ViewItemContext = "ViewItemContext",
+    ViewTitle = "ViewTitle",
+    CommentThreadTitle = "CommentThreadTitle",
+    CommentThreadActions = "CommentThreadActions",
+    CommentTitle = "CommentTitle",
+    CommentActions = "CommentActions"
+}
+export type MenuItemAction = {
+    __typename?: "MenuItemAction";
+    action?: Maybe<Scalars["String"]>;
+    when?: Maybe<Scalars["String"]>;
+};
+export type MenuItemActionContext = {
+    __typename?: "MenuItemActionContext";
+    context?: Maybe<Array<Maybe<MenuItemAction>>>;
+};
+export type MenuItemActionDebug = {
+    __typename?: "MenuItemActionDebug";
+    callstack?: Maybe<MenuItemActionContext>;
+    toolbar?: Maybe<Array<Maybe<MenuItemAction>>>;
+};
+export type MenuItemActionEditor = {
+    __typename?: "MenuItemActionEditor";
+    context?: Maybe<Array<Maybe<MenuItemAction>>>;
+    title?: Maybe<MenuItemActionEditorTitle>;
+};
+export type MenuItemActionEditorTitle = {
+    __typename?: "MenuItemActionEditorTitle";
+    own?: Maybe<Array<Maybe<MenuItemAction>>>;
+    context?: Maybe<Array<Maybe<MenuItemAction>>>;
+};
+export type MenuItemActionScm = {
+    __typename?: "MenuItemActionScm";
+    /**  The Source Control title menu  */
+    title?: Maybe<Array<Maybe<MenuItemAction>>>;
+    /**  The Source Control resource group context menu  */
+    resourceGroup?: Maybe<MenuItemActionContext>;
+    resource?: Maybe<MenuItemActionContext>;
+    change?: Maybe<MenuItemActionScmChange>;
+};
+export type MenuItemActionScmChange = {
+    __typename?: "MenuItemActionScmChange";
+    title?: Maybe<Array<Maybe<MenuItemAction>>>;
+};
+export type MenuItemActionView = {
+    __typename?: "MenuItemActionView";
+    /**  The contributed view title menu  */
+    title?: Maybe<Array<Maybe<MenuItemAction>>>;
+    /**  The contributed view item context menu  */
+    item?: Maybe<MenuItemActionContext>;
+};
+export type Menus = {
+    __typename?: "Menus";
+    /**  The Command Palette  */
+    commandPalette?: Maybe<Array<Maybe<MenuItemAction>>>;
+    /**  The file explorer  */
+    explorer?: Maybe<MenuItemActionContext>;
+    /**  The editor  */
+    editor?: Maybe<MenuItemActionEditor>;
+    /**  The debug  */
+    debug?: Maybe<MenuItemActionDebug>;
+    /**  The Source Control  */
+    scm?: Maybe<MenuItemActionScm>;
+    /**  The contributed view  */
+    view?: Maybe<MenuItemActionView>;
+    /**  The touch bar (macOS only)  */
+    touchBar?: Maybe<Array<Maybe<MenuItemAction>>>;
+};
+export type Mutation = {
+    __typename?: "Mutation";
+    dummy?: Maybe<Scalars["Int"]>;
+    /**  Create a new extension in the extension registry. */
+    createExtension: RegistryExtension;
+    /** Update an extension in the extension registry.
+     *
+     * Only authorized extension publishers may perform this mutation.
+     */
+    updateExtension: RegistryExtension;
+    /** Delete an extension from the extension registry.
+     *
+     * Only authorized extension publishers may perform this mutation.
+     */
+    deleteExtension: EmptyResponse;
+    /** 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: ExtensionRegistryPublishExtensionResult;
+};
+export type MutationCreateExtensionArgs = {
+    publisher: Scalars["ID"];
+    name: Scalars["String"];
+};
+export type MutationUpdateExtensionArgs = {
+    extension: Scalars["ID"];
+    name?: Maybe<Scalars["String"]>;
+};
+export type MutationDeleteExtensionArgs = {
+    extension: Scalars["ID"];
+};
+export type MutationPublishExtensionArgs = {
+    name?: Maybe<Scalars["String"]>;
+    version?: Maybe<Scalars["String"]>;
+    extensionID: Scalars["String"];
+    manifest: Scalars["String"];
+    bundle?: Maybe<Scalars["String"]>;
+    sourceMap?: Maybe<Scalars["String"]>;
+    force: Scalars["Boolean"];
+};
+export type Node = {
+    __typename?: "Node";
+    id: Scalars["ID"];
+};
+export type PageInfo = {
+    __typename?: "PageInfo";
+    hasNextPage: Scalars["Boolean"];
+};
+export type Query = {
+    __typename?: "Query";
+    dummy?: Maybe<Scalars["Int"]>;
+    extension?: Maybe<RegistryExtension>;
+    extensions: RegistryExtensionConnection;
+    releases?: Maybe<Array<Maybe<ExtensionRelease>>>;
+    /**  The extension registry.  */
+    extensionRegistry: ExtensionRegistry;
+    /** 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<DocSitePage>;
+};
+export type QueryExtensionArgs = {
+    extensionID: Scalars["String"];
+};
+export type QueryExtensionsArgs = {
+    first?: Maybe<Scalars["Int"]>;
+    query?: Maybe<Scalars["String"]>;
+    local: Scalars["Boolean"];
+    remote: Scalars["Boolean"];
+    prioritizeExtensionIDs?: Maybe<Array<Scalars["String"]>>;
+    includeWIP: Scalars["Boolean"];
+};
+export type QueryReleasesArgs = {
+    extensionID: Scalars["String"];
+};
+export type QueryDocSitePageArgs = {
+    path: Scalars["String"];
+};
+/**  An extenion's listing in the extension registry. */
+export type RegistryExtension = Node & {
+    __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<RegistryPublisher>;
+    /**  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<ExtensionManifest>;
+    /**  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<ExtensionRelease>>>;
+};
+/**  A list of registry extensions. */
+export type RegistryExtensionConnection = {
+    __typename?: "RegistryExtensionConnection";
+    /**  A list of registry extensions. */
+    nodes: Array<RegistryExtension>;
+    /** 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: PageInfo;
+    /**  location of the extension path for example: /extensions/<extension_user>/<extension_name>  */
+    url?: Maybe<Scalars["String"]>;
+    /** Errors that occured while communicating with remote registries to obtain the list of extensions.
+     *
+     * In order to be able to return local extensions even when the remote registry is unreachable, errors are
+     * recorded here instead of in the top-level GraphQL errors list.
+     */
+    error?: Maybe<Scalars["String"]>;
+};
+/**  A publisher of a registry extension. */
+export type RegistryPublisher = {
+    __typename?: "RegistryPublisher";
+    UserId?: Maybe<Scalars["String"]>;
+};
+/**  A list of publishers of extensions in the registry. */
+export type RegistryPublisherConnection = {
+    __typename?: "RegistryPublisherConnection";
+    /**  A list of publishers. */
+    nodes: Array<RegistryPublisher>;
+    /** 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: PageInfo;
+};
+export type Scripts = {
+    __typename?: "Scripts";
+    cdebasebuild?: Maybe<Scalars["String"]>;
+    cdebasepublish?: Maybe<Scalars["String"]>;
+};
+export type Subscription = {
+    __typename?: "Subscription";
+    dummy?: Maybe<Scalars["Int"]>;
+};
+//# sourceMappingURL=model.d.ts.map