@theia/plugin-ext 1.67.0-next.56 → 1.67.0-next.59

package/lib/common/plugin-protocol.d.ts

@@ -0,0 +1,960 @@
+/// <reference types="node" />
+import { RpcServer } from '@theia/core/lib/common/messaging/proxy-factory';
+import { RPCProtocol } from './rpc-protocol';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { LogPart, KeysToAnyValues, KeysToKeysToAnyValue } from './types';
+import { CharacterPair, CommentRule, PluginAPIFactory, Plugin, ThemeIcon } from './plugin-api-rpc';
+import { ExtPluginApi } from './plugin-ext-api-contribution';
+import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-schema';
+import { ProblemMatcherContribution, ProblemPatternContribution, TaskDefinition } from '@theia/task/lib/common';
+import { ColorDefinition } from '@theia/core/lib/common/color';
+import { ResourceLabelFormatter } from '@theia/core/lib/common/label-protocol';
+import { PluginIdentifiers } from './plugin-identifiers';
+import { JSONObject } from '@theia/core/shared/@lumino/coreutils';
+import { PreferenceSchema } from '@theia/core';
+export { PluginIdentifiers };
+export declare const hostedServicePath = "/services/hostedPlugin";
+/**
+ * Plugin engine (API) type, i.e. 'theiaPlugin', 'vscode', 'theiaHeadlessPlugin', etc.
+ */
+export type PluginEngine = string;
+/**
+ * This interface describes a package.json object.
+ */
+export interface PluginPackage {
+    name: string;
+    publisher: string | undefined;
+    version: string;
+    engines: {
+        [type in PluginEngine]: string;
+    };
+    theiaPlugin?: {
+        frontend?: string;
+        backend?: string;
+        headless?: string;
+    };
+    main?: string;
+    browser?: string;
+    displayName: string;
+    description: string;
+    contributes?: PluginPackageContribution;
+    packagePath: string;
+    activationEvents?: string[];
+    extensionDependencies?: string[];
+    extensionPack?: string[];
+    l10n?: string;
+    icon?: string;
+    extensionKind?: Array<'ui' | 'workspace'>;
+}
+export declare namespace PluginPackage {
+    function toPluginUrl(pck: PluginPackage | PluginModel, relativePath: string): string;
+}
+/**
+ * This interface describes a package.json contribution section object.
+ */
+export interface PluginPackageContribution {
+    authentication?: PluginPackageAuthenticationProvider[];
+    configuration?: JSONObject | JSONObject[];
+    configurationDefaults?: JSONObject;
+    languages?: PluginPackageLanguageContribution[];
+    grammars?: PluginPackageGrammarsContribution[];
+    customEditors?: PluginPackageCustomEditor[];
+    viewsContainers?: {
+        [location: string]: PluginPackageViewContainer[];
+    };
+    views?: {
+        [location: string]: PluginPackageView[];
+    };
+    viewsWelcome?: PluginPackageViewWelcome[];
+    commands?: PluginPackageCommand | PluginPackageCommand[];
+    menus?: {
+        [location: string]: PluginPackageMenu[];
+    };
+    submenus?: PluginPackageSubmenu[];
+    keybindings?: PluginPackageKeybinding | PluginPackageKeybinding[];
+    debuggers?: PluginPackageDebuggersContribution[];
+    snippets?: PluginPackageSnippetsContribution[];
+    themes?: PluginThemeContribution[];
+    iconThemes?: PluginIconThemeContribution[];
+    icons?: PluginIconContribution[];
+    colors?: PluginColorContribution[];
+    taskDefinitions?: PluginTaskDefinitionContribution[];
+    problemMatchers?: PluginProblemMatcherContribution[];
+    problemPatterns?: PluginProblemPatternContribution[];
+    jsonValidation?: PluginJsonValidationContribution[];
+    resourceLabelFormatters?: ResourceLabelFormatter[];
+    localizations?: PluginPackageLocalization[];
+    terminal?: PluginPackageTerminal;
+    notebooks?: PluginPackageNotebook[];
+    notebookRenderer?: PluginNotebookRendererContribution[];
+    notebookPreload?: PluginPackageNotebookPreload[];
+    mcpServerDefinitionProviders?: PluginPackageMcpServerDefinitionProviderContribution[];
+}
+export interface PluginPackageNotebook {
+    type: string;
+    displayName: string;
+    selector?: readonly {
+        filenamePattern?: string;
+        excludeFileNamePattern?: string;
+    }[];
+    priority?: string;
+}
+export interface PluginNotebookRendererContribution {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+    readonly entrypoint: string | {
+        readonly extends: string;
+        readonly path: string;
+    };
+    readonly requiresMessaging?: 'always' | 'optional' | 'never';
+}
+export interface PluginPackageNotebookPreload {
+    type: string;
+    entrypoint: string;
+}
+export interface PluginPackageMcpServerDefinitionProviderContribution {
+    id: string;
+    label: string;
+    description?: string;
+}
+export interface PluginPackageAuthenticationProvider {
+    id: string;
+    label: string;
+}
+export interface PluginPackageTerminalProfile {
+    title: string;
+    id: string;
+    icon?: string;
+}
+export interface PluginPackageTerminal {
+    profiles: PluginPackageTerminalProfile[];
+}
+export interface PluginPackageLocalization {
+    languageId: string;
+    languageName?: string;
+    localizedLanguageName?: string;
+    translations: PluginPackageTranslation[];
+    minimalTranslations?: {
+        [key: string]: string;
+    };
+}
+export interface PluginPackageTranslation {
+    id: string;
+    path: string;
+}
+export interface PluginPackageCustomEditor {
+    viewType: string;
+    displayName: string;
+    selector?: CustomEditorSelector[];
+    priority?: CustomEditorPriority;
+}
+export interface CustomEditorSelector {
+    readonly filenamePattern?: string;
+}
+export declare enum CustomEditorPriority {
+    default = "default",
+    builtin = "builtin",
+    option = "option"
+}
+export interface PluginPackageViewContainer {
+    id: string;
+    title: string;
+    icon: string;
+}
+export declare enum PluginViewType {
+    Tree = "tree",
+    Webview = "webview"
+}
+export interface PluginPackageView {
+    id: string;
+    name: string;
+    when?: string;
+    type?: string;
+}
+export interface PluginPackageViewWelcome {
+    view: string;
+    contents: string;
+    when?: string;
+    enablement?: string;
+}
+export interface PluginPackageCommand {
+    command: string;
+    title: string;
+    shortTitle?: string;
+    original?: string;
+    category?: string;
+    icon?: string | {
+        light: string;
+        dark: string;
+    };
+    enablement?: string;
+}
+export interface PluginPackageMenu {
+    command?: string;
+    submenu?: string;
+    alt?: string;
+    group?: string;
+    when?: string;
+}
+export interface PluginPackageSubmenu {
+    id: string;
+    label: string;
+    icon: IconUrl;
+}
+export interface PluginPackageKeybinding {
+    key?: string;
+    command: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+    args?: any;
+}
+export interface PluginPackageGrammarsContribution {
+    language?: string;
+    scopeName: string;
+    path: string;
+    embeddedLanguages?: ScopeMap;
+    tokenTypes?: ScopeMap;
+    injectTo?: string[];
+}
+export interface ScopeMap {
+    [scopeName: string]: string;
+}
+export interface PluginPackageSnippetsContribution {
+    language?: string;
+    path?: string;
+}
+export interface PluginColorContribution {
+    id?: string;
+    description?: string;
+    defaults?: {
+        light?: string;
+        dark?: string;
+        highContrast?: string;
+    };
+}
+export type PluginUiTheme = 'vs' | 'vs-dark' | 'hc-black';
+export interface PluginThemeContribution {
+    id?: string;
+    label?: string;
+    description?: string;
+    path?: string;
+    uiTheme?: PluginUiTheme;
+}
+export interface PluginIconThemeContribution {
+    id?: string;
+    label?: string;
+    description?: string;
+    path?: string;
+    uiTheme?: PluginUiTheme;
+}
+export interface PluginIconContribution {
+    [id: string]: {
+        description: string;
+        default: {
+            fontPath: string;
+            fontCharacter: string;
+        } | string;
+    };
+}
+export interface PlatformSpecificAdapterContribution {
+    program?: string;
+    args?: string[];
+    runtime?: string;
+    runtimeArgs?: string[];
+}
+/**
+ * This interface describes a package.json debuggers contribution section object.
+ */
+export interface PluginPackageDebuggersContribution extends PlatformSpecificAdapterContribution {
+    type: string;
+    label?: string;
+    languages?: string[];
+    enableBreakpointsFor?: {
+        languageIds: string[];
+    };
+    configurationAttributes: {
+        [request: string]: IJSONSchema;
+    };
+    configurationSnippets: IJSONSchemaSnippet[];
+    variables?: ScopeMap;
+    adapterExecutableCommand?: string;
+    win?: PlatformSpecificAdapterContribution;
+    winx86?: PlatformSpecificAdapterContribution;
+    windows?: PlatformSpecificAdapterContribution;
+    osx?: PlatformSpecificAdapterContribution;
+    linux?: PlatformSpecificAdapterContribution;
+}
+/**
+ * This interface describes a package.json languages contribution section object.
+ */
+export interface PluginPackageLanguageContribution {
+    id: string;
+    extensions?: string[];
+    filenames?: string[];
+    filenamePatterns?: string[];
+    firstLine?: string;
+    aliases?: string[];
+    mimetypes?: string[];
+    configuration?: string;
+    icon?: IconUrl;
+}
+export interface PluginPackageLanguageContributionConfiguration {
+    comments?: CommentRule;
+    brackets?: CharacterPair[];
+    autoClosingPairs?: (CharacterPair | AutoClosingPairConditional)[];
+    surroundingPairs?: (CharacterPair | AutoClosingPair)[];
+    wordPattern?: string;
+    indentationRules?: IndentationRules;
+    folding?: FoldingRules;
+    onEnterRules?: OnEnterRule[];
+}
+export interface PluginTaskDefinitionContribution {
+    type: string;
+    required: string[];
+    properties?: IJSONSchema['properties'];
+}
+export interface PluginProblemMatcherContribution extends ProblemMatcherContribution {
+    name: string;
+}
+export interface PluginProblemPatternContribution extends ProblemPatternContribution {
+    name: string;
+}
+export interface PluginJsonValidationContribution {
+    fileMatch: string | string[];
+    url: string;
+}
+export declare const PluginScanner: unique symbol;
+/**
+ * This scanner process package.json object and returns plugin metadata objects.
+ */
+export interface PluginScanner {
+    /**
+     * The type of plugin's API (engine name)
+     */
+    apiType: PluginEngine;
+    /**
+     * Creates plugin's model.
+     *
+     * @param {PluginPackage} plugin
+     * @returns {PluginModel}
+     */
+    getModel(plugin: PluginPackage): PluginModel;
+    /**
+     * Creates plugin's lifecycle.
+     *
+     * @returns {PluginLifecycle}
+     */
+    getLifecycle(plugin: PluginPackage): PluginLifecycle;
+    getContribution(plugin: PluginPackage): Promise<PluginContribution | undefined>;
+    /**
+     * A mapping between a dependency as its defined in package.json
+     * and its deployable form, e.g. `publisher.name` -> `vscode:extension/publisher.name`
+     */
+    getDependencies(plugin: PluginPackage): Map<string, string> | undefined;
+}
+/**
+ * A plugin resolver is handling how to resolve a plugin link into a local resource.
+ */
+export declare const PluginDeployerResolver: unique symbol;
+/**
+ * A resolver handle a set of resource
+ */
+export interface PluginDeployerResolver {
+    init?(pluginDeployerResolverInit: PluginDeployerResolverInit): void;
+    accept(pluginSourceId: string): boolean;
+    resolve(pluginResolverContext: PluginDeployerResolverContext, options?: PluginDeployOptions): Promise<void>;
+}
+export declare const PluginDeployerDirectoryHandler: unique symbol;
+export interface PluginDeployerDirectoryHandler {
+    accept(pluginDeployerEntry: PluginDeployerEntry): Promise<boolean>;
+    handle(context: PluginDeployerDirectoryHandlerContext): Promise<void>;
+}
+export declare const PluginDeployerFileHandler: unique symbol;
+export interface PluginDeployerFileHandler {
+    accept(pluginDeployerEntry: PluginDeployerEntry): Promise<boolean>;
+    handle(context: PluginDeployerFileHandlerContext): Promise<void>;
+}
+export interface PluginDeployerResolverInit {
+}
+export interface PluginDeployerResolverContext {
+    addPlugin(pluginId: string, path: string): void;
+    getPlugins(): PluginDeployerEntry[];
+    getOriginId(): string;
+}
+export interface PluginDeployerStartContext {
+    readonly userEntries: string[];
+    readonly systemEntries: string[];
+}
+export declare const PluginDeployer: unique symbol;
+export interface PluginDeployer {
+    start(): Promise<void>;
+}
+export declare const PluginDeployerParticipant: unique symbol;
+/**
+ * A participant can hook into the plugin deployer lifecycle.
+ */
+export interface PluginDeployerParticipant {
+    onWillStart?(context: PluginDeployerStartContext): Promise<void>;
+}
+export declare enum PluginDeployerEntryType {
+    FRONTEND = 0,
+    BACKEND = 1,
+    HEADLESS = 2
+}
+/**
+ * Whether a plugin installed by a user or system.
+ */
+export declare enum PluginType {
+    System = 0,
+    User = 1
+}
+export interface UnresolvedPluginEntry {
+    id: string;
+    type?: PluginType;
+}
+export interface PluginDeployerEntry {
+    /**
+     * ID (before any resolution)
+     */
+    id(): string;
+    /**
+     * Original resolved path
+     */
+    originalPath(): string;
+    /**
+     * Local path on the filesystem.
+     */
+    path(): string;
+    /**
+     * Get a specific entry
+     */
+    getValue<T>(key: string): T;
+    /**
+     * Store a value
+     */
+    storeValue<T>(key: string, value: T): void;
+    /**
+     * Update path
+     */
+    updatePath(newPath: string): void;
+    getChanges(): string[];
+    isFile(): Promise<boolean>;
+    isDirectory(): Promise<boolean>;
+    /**
+     * Resolved if a resolver has handle this plugin
+     */
+    isResolved(): boolean;
+    resolvedBy(): string;
+    /**
+     * Accepted when a handler is telling this location can go live
+     */
+    isAccepted(...types: PluginDeployerEntryType[]): boolean;
+    accept(...types: PluginDeployerEntryType[]): void;
+    hasError(): boolean;
+    type: PluginType;
+    /**
+     * A fs path to a directory where a plugin is located.
+     * Depending on a plugin format it can be different from `path`.
+     * Use `path` if you want to resolve something within a plugin, like `README.md` file.
+     * Use `rootPath` if you want to manipulate the entire plugin location, like delete or move it.
+     */
+    rootPath: string;
+}
+export interface PluginDeployerFileHandlerContext {
+    unzip(sourcePath: string, destPath: string): Promise<void>;
+    pluginEntry(): PluginDeployerEntry;
+}
+export interface PluginDeployerDirectoryHandlerContext {
+    copy(origin: string, target: string): Promise<void>;
+    pluginEntry(): PluginDeployerEntry;
+}
+/**
+ * This interface describes a plugin model object, which is populated from package.json.
+ */
+export interface PluginModel {
+    id: string;
+    name: string;
+    publisher: string;
+    version: string;
+    displayName: string;
+    description: string;
+    engine: {
+        type: PluginEngine;
+        version: string;
+    };
+    entryPoint: PluginEntryPoint;
+    packageUri: string;
+    /**
+     * @deprecated since 1.1.0 - because it lead to problems with getting a relative path
+     * needed by Icon Themes to correctly load Fonts, use packageUri instead.
+     */
+    packagePath: string;
+    iconUrl?: string;
+    l10n?: string;
+    readmeUrl?: string;
+    licenseUrl?: string;
+}
+export interface PluginEntryPoint {
+    frontend?: string;
+    backend?: string;
+    headless?: string;
+}
+/**
+ * This interface describes some static plugin contributions.
+ */
+export interface PluginContribution {
+    activationEvents?: string[];
+    authentication?: AuthenticationProviderInformation[];
+    configuration?: PreferenceSchema[];
+    configurationDefaults?: JSONObject;
+    languages?: LanguageContribution[];
+    grammars?: GrammarsContribution[];
+    customEditors?: CustomEditor[];
+    viewsContainers?: {
+        [location: string]: ViewContainer[];
+    };
+    views?: {
+        [location: string]: View[];
+    };
+    viewsWelcome?: ViewWelcome[];
+    commands?: PluginCommand[];
+    menus?: {
+        [location: string]: Menu[];
+    };
+    submenus?: Submenu[];
+    keybindings?: Keybinding[];
+    debuggers?: DebuggerContribution[];
+    snippets?: SnippetContribution[];
+    themes?: ThemeContribution[];
+    iconThemes?: IconThemeContribution[];
+    icons?: IconContribution[];
+    colors?: ColorDefinition[];
+    taskDefinitions?: TaskDefinition[];
+    problemMatchers?: ProblemMatcherContribution[];
+    problemPatterns?: ProblemPatternContribution[];
+    resourceLabelFormatters?: ResourceLabelFormatter[];
+    localizations?: Localization[];
+    terminalProfiles?: TerminalProfile[];
+    notebooks?: NotebookContribution[];
+    notebookRenderer?: NotebookRendererContribution[];
+    notebookPreload?: notebookPreloadContribution[];
+}
+export interface NotebookContribution {
+    type: string;
+    displayName: string;
+    selector?: readonly {
+        filenamePattern?: string;
+        excludeFileNamePattern?: string;
+    }[];
+    priority?: string;
+}
+export interface NotebookRendererContribution {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+    readonly entrypoint: string | {
+        readonly extends: string;
+        readonly path: string;
+    };
+    readonly requiresMessaging?: 'always' | 'optional' | 'never';
+}
+export interface notebookPreloadContribution {
+    type: string;
+    entrypoint: string;
+}
+export interface AuthenticationProviderInformation {
+    id: string;
+    label: string;
+}
+export interface TerminalProfile {
+    title: string;
+    id: string;
+    icon?: string;
+}
+export interface Localization {
+    languageId: string;
+    languageName?: string;
+    localizedLanguageName?: string;
+    translations: Translation[];
+    minimalTranslations?: {
+        [key: string]: string;
+    };
+}
+export interface Translation {
+    id: string;
+    path: string;
+    cachedContents?: {
+        [scope: string]: {
+            [key: string]: string;
+        };
+    };
+}
+export interface SnippetContribution {
+    uri: string;
+    source: string;
+    language?: string;
+}
+export type UiTheme = 'vs' | 'vs-dark' | 'hc-black';
+export interface ThemeContribution {
+    id?: string;
+    label?: string;
+    description?: string;
+    uri: string;
+    uiTheme?: UiTheme;
+}
+export interface IconThemeContribution {
+    id: string;
+    label?: string;
+    description?: string;
+    uri: string;
+    uiTheme?: UiTheme;
+}
+export interface IconDefinition {
+    fontCharacter: string;
+    location: string;
+}
+export type IconDefaults = ThemeIcon | IconDefinition;
+export interface IconContribution {
+    id: string;
+    extensionId: string;
+    description: string | undefined;
+    defaults: IconDefaults;
+}
+export declare namespace IconContribution {
+    function isIconDefinition(defaults: IconDefaults): defaults is IconDefinition;
+}
+export interface GrammarsContribution {
+    format: 'json' | 'plist';
+    language?: string;
+    scope: string;
+    grammar?: string | object;
+    grammarLocation?: string;
+    embeddedLanguages?: ScopeMap;
+    tokenTypes?: ScopeMap;
+    injectTo?: string[];
+    balancedBracketScopes?: string[];
+    unbalancedBracketScopes?: string[];
+}
+/**
+ * The language contribution
+ */
+export interface LanguageContribution {
+    id: string;
+    extensions?: string[];
+    filenames?: string[];
+    filenamePatterns?: string[];
+    firstLine?: string;
+    aliases?: string[];
+    mimetypes?: string[];
+    configuration?: LanguageConfiguration;
+    /**
+     * @internal
+     */
+    icon?: IconUrl;
+}
+export interface RegExpOptions {
+    pattern: string;
+    flags?: string;
+}
+export interface LanguageConfiguration {
+    brackets?: CharacterPair[];
+    indentationRules?: IndentationRules;
+    surroundingPairs?: AutoClosingPair[];
+    autoClosingPairs?: AutoClosingPairConditional[];
+    comments?: CommentRule;
+    folding?: FoldingRules;
+    wordPattern?: string | RegExpOptions;
+    onEnterRules?: OnEnterRule[];
+}
+/**
+ * This interface describes a package.json debuggers contribution section object.
+ */
+export interface DebuggerContribution extends PlatformSpecificAdapterContribution {
+    type: string;
+    label?: string;
+    languages?: string[];
+    enableBreakpointsFor?: {
+        languageIds: string[];
+    };
+    configurationAttributes?: {
+        [request: string]: IJSONSchema;
+    };
+    configurationSnippets?: IJSONSchemaSnippet[];
+    variables?: ScopeMap;
+    adapterExecutableCommand?: string;
+    win?: PlatformSpecificAdapterContribution;
+    winx86?: PlatformSpecificAdapterContribution;
+    windows?: PlatformSpecificAdapterContribution;
+    osx?: PlatformSpecificAdapterContribution;
+    linux?: PlatformSpecificAdapterContribution;
+}
+export interface IndentationRules {
+    increaseIndentPattern: string | RegExpOptions;
+    decreaseIndentPattern: string | RegExpOptions;
+    unIndentedLinePattern?: string | RegExpOptions;
+    indentNextLinePattern?: string | RegExpOptions;
+}
+export interface AutoClosingPair {
+    close: string;
+    open: string;
+}
+export interface AutoClosingPairConditional extends AutoClosingPair {
+    notIn?: string[];
+}
+export interface FoldingMarkers {
+    start: string | RegExpOptions;
+    end: string | RegExpOptions;
+}
+export interface FoldingRules {
+    offSide?: boolean;
+    markers?: FoldingMarkers;
+}
+export interface OnEnterRule {
+    beforeText: string | RegExpOptions;
+    afterText?: string | RegExpOptions;
+    previousLineText?: string | RegExpOptions;
+    action: EnterAction;
+}
+export interface EnterAction {
+    indent: 'none' | 'indent' | 'outdent' | 'indentOutdent';
+    appendText?: string;
+    removeText?: number;
+}
+/**
+ * Custom Editors contribution
+ */
+export interface CustomEditor {
+    viewType: string;
+    displayName: string;
+    selector: CustomEditorSelector[];
+    priority: CustomEditorPriority;
+}
+/**
+ * Views Containers contribution
+ */
+export interface ViewContainer {
+    id: string;
+    title: string;
+    iconUrl: string;
+    themeIcon?: string;
+}
+/**
+ * View contribution
+ */
+export interface View {
+    id: string;
+    name: string;
+    when?: string;
+    type?: string;
+}
+/**
+ * View Welcome contribution
+ */
+export interface ViewWelcome {
+    view: string;
+    content: string;
+    when?: string;
+    enablement?: string;
+    order: number;
+}
+export interface PluginCommand {
+    command: string;
+    title: string;
+    shortTitle?: string;
+    originalTitle?: string;
+    category?: string;
+    iconUrl?: IconUrl;
+    themeIcon?: string;
+    enablement?: string;
+}
+export type IconUrl = string | {
+    light: string;
+    dark: string;
+};
+/**
+ * Menu contribution
+ */
+export interface Menu {
+    command?: string;
+    submenu?: string;
+    alt?: string;
+    group?: string;
+    when?: string;
+}
+export interface Submenu {
+    id: string;
+    label: string;
+    icon?: IconUrl;
+}
+/**
+ * Keybinding contribution
+ */
+export interface Keybinding {
+    keybinding?: string;
+    command: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+    args?: any;
+}
+/**
+ * This interface describes a plugin lifecycle object.
+ */
+export interface PluginLifecycle {
+    startMethod: string;
+    stopMethod: string;
+    /**
+     * Frontend module name, frontend plugin should expose this name.
+     */
+    frontendModuleName?: string;
+    /**
+     * Path to the script which should do some initialization before frontend plugin is loaded.
+     */
+    frontendInitPath?: string;
+    /**
+     * Path to the script which should do some initialization before backend plugin is loaded.
+     */
+    backendInitPath?: string;
+}
+/**
+ * The export function of initialization module of backend plugin.
+ */
+export interface BackendInitializationFn {
+    (apiFactory: PluginAPIFactory, plugin: Plugin): void;
+}
+export interface BackendLoadingFn {
+    (rpc: RPCProtocol, plugin: Plugin): void;
+}
+export interface PluginContext {
+    subscriptions: Disposable[];
+}
+export interface ExtensionContext {
+    subscriptions: Disposable[];
+}
+export interface PluginMetadata {
+    host: string;
+    model: PluginModel;
+    lifecycle: PluginLifecycle;
+    isUnderDevelopment?: boolean;
+    outOfSync: boolean;
+}
+export declare const MetadataProcessor: unique symbol;
+export interface MetadataProcessor {
+    process(pluginMetadata: PluginMetadata): void;
+}
+export declare function getPluginId(plugin: PluginPackage | PluginModel): string;
+export declare function buildFrontendModuleName(plugin: PluginPackage | PluginModel): string;
+export declare const HostedPluginClient: unique symbol;
+export interface HostedPluginClient {
+    postMessage(pluginHost: string, buffer: Uint8Array): Promise<void>;
+    log(logPart: LogPart): void;
+    onDidDeploy(): void;
+}
+export interface PluginDependencies {
+    metadata: PluginMetadata;
+    /**
+     * Actual listing of plugin dependencies.
+     * Mapping from {@link PluginIdentifiers.UnversionedId external representation} of plugin identity to a string
+     * that can be used to identify the resolver for the specific plugin case, e.g. with scheme `vscode://<id>`.
+     */
+    mapping?: Map<string, string>;
+}
+export declare const PluginDeployerHandler: unique symbol;
+export interface PluginDeployerHandler {
+    deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<number | undefined>;
+    deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<number | undefined>;
+    getDeployedPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]>;
+    getDeployedPlugins(): Promise<DeployedPlugin[]>;
+    getDeployedPluginsById(pluginId: string): DeployedPlugin[];
+    getDeployedPlugin(pluginId: PluginIdentifiers.VersionedId): DeployedPlugin | undefined;
+    /**
+     * Removes the plugin from the location it originally resided on disk.
+     * Unless `--uncompressed-plugins-in-place` is passed to the CLI, this operation is safe.
+     */
+    uninstallPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean>;
+    /**
+     * Removes the plugin from the locations to which it had been deployed.
+     * This operation is not safe - references to deleted assets may remain.
+     */
+    undeployPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean>;
+    getPluginDependencies(pluginToBeInstalled: PluginDeployerEntry): Promise<PluginDependencies | undefined>;
+    /**
+     * Marks the given plugins as "disabled". While the plugin remains installed, it will no longer
+     * be used. Has no effect if the plugin is not installed
+     * @param pluginId the plugin to disable
+     * @returns whether the plugin was installed, enabled and could be disabled
+     */
+    disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean>;
+    /**
+     * Marks the given plugins as "enabled". Has no effect if the plugin is not installed.
+     * @param pluginId the plugin to enabled
+     * @returns whether the plugin was installed, disabled and could be enabled
+     */
+    enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean>;
+}
+export interface DeployedPlugin {
+    /**
+     * defaults to system
+     */
+    type?: PluginType;
+    metadata: PluginMetadata;
+    contributes?: PluginContribution;
+}
+export declare const HostedPluginServer: unique symbol;
+export interface HostedPluginServer extends RpcServer<HostedPluginClient> {
+    getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]>;
+    getInstalledPluginIds(): Promise<PluginIdentifiers.VersionedId[]>;
+    getUninstalledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]>;
+    getDisabledPluginIds(): Promise<readonly PluginIdentifiers.UnversionedId[]>;
+    getDeployedPlugins(ids: PluginIdentifiers.VersionedId[]): Promise<DeployedPlugin[]>;
+    getExtPluginAPI(): Promise<ExtPluginApi[]>;
+    onMessage(targetHost: string, message: Uint8Array): Promise<void>;
+}
+export declare const PLUGIN_HOST_BACKEND = "main";
+export interface WorkspaceStorageKind {
+    workspace?: string | undefined;
+    roots: string[];
+}
+export type GlobalStorageKind = undefined;
+export type PluginStorageKind = GlobalStorageKind | WorkspaceStorageKind;
+export interface PluginDeployOptions {
+    version: string;
+    /** Instructs the deployer to ignore any existing plugins with different versions */
+    ignoreOtherVersions?: boolean;
+}
+export declare const pluginServerJsonRpcPath = "/services/plugin-ext";
+export declare const PluginServer: unique symbol;
+export interface PluginServer {
+    /**
+     * Deploy a plugin.
+     *
+     * @param type whether a plugin is installed by a system or a user, defaults to a user
+     */
+    install(pluginEntry: string, type?: PluginType, options?: PluginDeployOptions): Promise<void>;
+    uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void>;
+    enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean>;
+    disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean>;
+    getInstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]>;
+    getUninstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]>;
+    getDisabledPlugins(): Promise<readonly PluginIdentifiers.UnversionedId[]>;
+    setStorageValue(key: string, value: KeysToAnyValues, kind: PluginStorageKind): Promise<boolean>;
+    getStorageValue(key: string, kind: PluginStorageKind): Promise<KeysToAnyValues>;
+    getAllStorageValues(kind: PluginStorageKind): Promise<KeysToKeysToAnyValue>;
+}
+export declare const ServerPluginRunner: unique symbol;
+export interface ServerPluginRunner {
+    acceptMessage(pluginHostId: string, jsonMessage: Uint8Array): boolean;
+    onMessage(pluginHostId: string, jsonMessage: Uint8Array): void;
+    setClient(client: HostedPluginClient): void;
+    setDefault(defaultRunner: ServerPluginRunner): void;
+    clientClosed(): void;
+}
+export declare const PluginHostEnvironmentVariable: unique symbol;
+export interface PluginHostEnvironmentVariable {
+    process(env: NodeJS.ProcessEnv): void;
+}
+//# sourceMappingURL=plugin-protocol.d.ts.map