@theia/core

  • Version 1.26.0
  • Published
  • 8.74 MB
  • 68 dependencies
  • EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 license

Install

npm i @theia/core
yarn add @theia/core
pnpm add @theia/core

Overview

Theia is a cloud & desktop IDE framework implemented in TypeScript.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ACCOUNTS_MENU

const ACCOUNTS_MENU: MenuPath;

    variable ACCOUNTS_SUBMENU

    const ACCOUNTS_SUBMENU: string[];

      variable BackendStopwatch

      const BackendStopwatch: Symbol;

        variable BackendStopwatchOptions

        const BackendStopwatchOptions: Symbol;

          variable CommandContribution

          const CommandContribution: Symbol;

            variable CommandService

            const CommandService: Symbol;

              variable commandServicePath

              const commandServicePath: string;

                variable ConnectionHandler

                const ConnectionHandler: Symbol;

                  variable ContributionFilterRegistry

                  const ContributionFilterRegistry: Symbol;

                    variable ContributionProvider

                    const ContributionProvider: Symbol;

                      variable Filter

                      const Filter: Symbol;

                        variable FilterContribution

                        const FilterContribution: Symbol;

                          variable ILogger

                          const ILogger: Symbol;

                            variable isOSX

                            const isOSX: boolean;

                              variable isWindows

                              const isWindows: boolean;

                                variable logger

                                let logger: ILogger;

                                  variable LoggerFactory

                                  const LoggerFactory: Symbol;

                                    variable LoggerName

                                    const LoggerName: Symbol;
                                      const MAIN_MENU_BAR: MenuPath;

                                        variable MAX_SAFE_INTEGER

                                        const MAX_SAFE_INTEGER: number;
                                        • The maximum safe integer (2^32-1) is used as a placeholder for large numbers which are not allowed to be floats. For example as line/column arguments for monaco-ranges.

                                        variable MEMORY_TEXT

                                        const MEMORY_TEXT: string;
                                          const MenuContribution: Symbol;

                                            variable messageServicePath

                                            const messageServicePath: string;

                                              variable ProgressClient

                                              const ProgressClient: Symbol;

                                                variable ResourceProvider

                                                const ResourceProvider: Symbol;

                                                  variable ResourceResolver

                                                  const ResourceResolver: Symbol;

                                                    variable rootLoggerName

                                                    const rootLoggerName: string;

                                                      variable SETTINGS_MENU

                                                      const SETTINGS_MENU: MenuPath;

                                                        variable stopwatchPath

                                                        const stopwatchPath: string;
                                                        • API path of the stopwatch service that exposes the back-end stopwatch to clients.

                                                        variable UNTITLED_SCHEME

                                                        const UNTITLED_SCHEME: string;

                                                          Functions

                                                          function bindContribution

                                                          bindContribution: (
                                                          bindable: Bindable,
                                                          service: interfaces.ServiceIdentifier<any>,
                                                          contributions: interfaces.ServiceIdentifier<any>[]
                                                          ) => void;
                                                          • Helper function to bind a service to a list of contributions easily.

                                                            Parameter bindable

                                                            a Container or the bind function directly.

                                                            Parameter service

                                                            an already bound service to refer the contributions to.

                                                            Parameter contributions

                                                            array of contribution identifiers to bind the service to.

                                                          function bindContributionProvider

                                                          bindContributionProvider: (bindable: Bindable, id: symbol) => void;

                                                            function cancelled

                                                            cancelled: () => Error;

                                                              function checkCancelled

                                                              checkCancelled: (token?: CancellationToken) => void;

                                                                function cmd

                                                                cmd: (command: string, ...args: string[]) => CMD;

                                                                  function commonPrefixLength

                                                                  commonPrefixLength: (a: string, b: string) => number;
                                                                  • Returns

                                                                    the length of the common prefix of the two strings.

                                                                  function compare

                                                                  compare: (a: string, b: string) => number;

                                                                    function compareIgnoreCase

                                                                    compareIgnoreCase: (a: string, b: string) => number;

                                                                      function compareSubstring

                                                                      compareSubstring: (
                                                                      a: string,
                                                                      b: string,
                                                                      aStart?: number,
                                                                      aEnd?: number,
                                                                      bStart?: number,
                                                                      bEnd?: number
                                                                      ) => number;

                                                                        function compareSubstringIgnoreCase

                                                                        compareSubstringIgnoreCase: (
                                                                        a: string,
                                                                        b: string,
                                                                        aStart?: number,
                                                                        aEnd?: number,
                                                                        bStart?: number,
                                                                        bEnd?: number
                                                                        ) => number;

                                                                          function createUntitledURI

                                                                          createUntitledURI: (extension?: string, parent?: URI) => URI;

                                                                            function deepClone

                                                                            deepClone: <T>(obj: T) => T;

                                                                              function deepFreeze

                                                                              deepFreeze: <T>(obj: T) => T;

                                                                                function disposableTimeout

                                                                                disposableTimeout: (
                                                                                handler: TimerHandler,
                                                                                timeout?: number,
                                                                                ...arguments: any[]
                                                                                ) => Disposable;

                                                                                  function endsWith

                                                                                  endsWith: (haystack: string, needle: string) => boolean;
                                                                                  • Determines if haystack ends with needle.

                                                                                  function equalsIgnoreCase

                                                                                  equalsIgnoreCase: (a: string, b: string) => boolean;

                                                                                    function escapeInvisibleChars

                                                                                    escapeInvisibleChars: (value: string) => string;

                                                                                      function escapeRegExpCharacters

                                                                                      escapeRegExpCharacters: (value: string) => string;
                                                                                      • Escapes regular expression characters in a given string

                                                                                      function isCancelled

                                                                                      isCancelled: (err: Error | undefined) => boolean;

                                                                                        function isEmpty

                                                                                        isEmpty: (arg: Object) => boolean;
                                                                                        • true if the argument is an empty object. Otherwise, false.

                                                                                        function isLowerAsciiLetter

                                                                                        isLowerAsciiLetter: (code: number) => boolean;

                                                                                          function isUpperAsciiLetter

                                                                                          isUpperAsciiLetter: (code: number) => boolean;

                                                                                            function notEmpty

                                                                                            notEmpty: <T>(arg: T | undefined | null) => arg is T;

                                                                                              function nullToUndefined

                                                                                              nullToUndefined: <T>(nullable: MaybeNull<T>) => MaybeUndefined<T>;
                                                                                              • Creates a shallow copy with all ownkeys of the original object that are null made undefined

                                                                                              function setRootLogger

                                                                                              setRootLogger: (aLogger: ILogger) => void;

                                                                                                function split

                                                                                                split: (s: string, splitter: string) => IterableIterator<string>;

                                                                                                  function startsWithIgnoreCase

                                                                                                  startsWithIgnoreCase: (str: string, candidate: string) => boolean;

                                                                                                    function unescapeInvisibleChars

                                                                                                    unescapeInvisibleChars: (value: string) => string;

                                                                                                      function unreachable

                                                                                                      unreachable: (_never: never, message?: string) => never;
                                                                                                      • Throws when called and statically makes sure that all variants of a type were consumed.

                                                                                                      function unsetRootLogger

                                                                                                      unsetRootLogger: () => void;
                                                                                                      • Counterpart of the #setRootLogger(ILogger). Restores the console.xxx bindings to the original one. Invoking has no side-effect if setRootLogger was not called before. Multiple function invocation has no side-effect either.

                                                                                                      Classes

                                                                                                      class AbstractReferenceCollection

                                                                                                      abstract class AbstractReferenceCollection<K, V extends Disposable>
                                                                                                      implements Disposable {}

                                                                                                        constructor

                                                                                                        constructor();

                                                                                                          property onDidCreate

                                                                                                          readonly onDidCreate: Event<V>;

                                                                                                            property onDidCreateEmitter

                                                                                                            protected readonly onDidCreateEmitter: Emitter<V>;

                                                                                                              property onWillDispose

                                                                                                              readonly onWillDispose: Event<V>;

                                                                                                                property onWillDisposeEmitter

                                                                                                                protected readonly onWillDisposeEmitter: Emitter<V>;

                                                                                                                  property references

                                                                                                                  protected readonly references: Map<string, DisposableCollection>;

                                                                                                                    property toDispose

                                                                                                                    protected readonly toDispose: DisposableCollection;

                                                                                                                      method acquire

                                                                                                                      abstract acquire: (args: K) => MaybePromise<Reference<V>>;

                                                                                                                        method clear

                                                                                                                        clear: () => void;

                                                                                                                          method createReferences

                                                                                                                          protected createReferences: (key: string, value: V) => DisposableCollection;

                                                                                                                            method dispose

                                                                                                                            dispose: () => void;

                                                                                                                              method doAcquire

                                                                                                                              protected doAcquire: (key: string, object: V) => Reference<V>;

                                                                                                                                method get

                                                                                                                                get: (args: K) => V | undefined;

                                                                                                                                  method has

                                                                                                                                  has: (args: K) => boolean;

                                                                                                                                    method keys

                                                                                                                                    keys: () => K[];

                                                                                                                                      method toKey

                                                                                                                                      protected toKey: (args: K) => string;

                                                                                                                                        method values

                                                                                                                                        values: () => V[];

                                                                                                                                          class ActionMenuNode

                                                                                                                                          class ActionMenuNode implements MenuNode {}
                                                                                                                                          • Node representing an action in the menu tree structure. It's based on MenuAction for which it tries to determine the best label, icon and sortString with the given data.

                                                                                                                                          constructor

                                                                                                                                          constructor(action: MenuAction, commands: CommandRegistry);

                                                                                                                                            property action

                                                                                                                                            readonly action: MenuAction;

                                                                                                                                              property altNode

                                                                                                                                              readonly altNode: ActionMenuNode;

                                                                                                                                                property commands

                                                                                                                                                protected readonly commands: CommandRegistry;

                                                                                                                                                  property icon

                                                                                                                                                  readonly icon: string;

                                                                                                                                                    property id

                                                                                                                                                    readonly id: string;

                                                                                                                                                      property label

                                                                                                                                                      readonly label: string;

                                                                                                                                                        property sortString

                                                                                                                                                        readonly sortString: string;

                                                                                                                                                          class AsyncEmitter

                                                                                                                                                          class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {}

                                                                                                                                                            property deliveryQueue

                                                                                                                                                            protected deliveryQueue: Promise<void>;

                                                                                                                                                              method deliver

                                                                                                                                                              protected deliver: (
                                                                                                                                                              listeners: Callback[],
                                                                                                                                                              event: Omit<T, 'waitUntil'>,
                                                                                                                                                              token: CancellationToken,
                                                                                                                                                              promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>
                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                method fire

                                                                                                                                                                fire: (
                                                                                                                                                                event: Omit<T, 'waitUntil'>,
                                                                                                                                                                token?: CancellationToken,
                                                                                                                                                                promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>
                                                                                                                                                                ) => Promise<void>;
                                                                                                                                                                • Fire listeners async one after another.

                                                                                                                                                                class CancellationError

                                                                                                                                                                class CancellationError extends Error {}

                                                                                                                                                                  constructor

                                                                                                                                                                  constructor();

                                                                                                                                                                    class CancellationTokenSource

                                                                                                                                                                    class CancellationTokenSource {}

                                                                                                                                                                      property token

                                                                                                                                                                      readonly token: CancellationToken;

                                                                                                                                                                        method cancel

                                                                                                                                                                        cancel: () => void;

                                                                                                                                                                          method dispose

                                                                                                                                                                          dispose: () => void;

                                                                                                                                                                            class CommandRegistry

                                                                                                                                                                            class CommandRegistry implements CommandService {}
                                                                                                                                                                            • The command registry manages commands and handlers.

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(contributionProvider: ContributionProvider<CommandContribution>);

                                                                                                                                                                              property commandIds

                                                                                                                                                                              readonly commandIds: string[];
                                                                                                                                                                              • Get all registered commands identifiers.

                                                                                                                                                                              property commands

                                                                                                                                                                              readonly commands: Command[];
                                                                                                                                                                              • Get all registered commands.

                                                                                                                                                                              property contributionProvider

                                                                                                                                                                              protected readonly contributionProvider: ContributionProvider<CommandContribution>;

                                                                                                                                                                                property fireDidChange

                                                                                                                                                                                protected fireDidChange: () => Promise<void>;

                                                                                                                                                                                  property onCommandsChanged

                                                                                                                                                                                  readonly onCommandsChanged: Event<void>;

                                                                                                                                                                                    property onCommandsChangedEmitter

                                                                                                                                                                                    protected readonly onCommandsChangedEmitter: Emitter<void>;

                                                                                                                                                                                      property onDidExecuteCommand

                                                                                                                                                                                      readonly onDidExecuteCommand: Event<CommandEvent>;

                                                                                                                                                                                        property onDidExecuteCommandEmitter

                                                                                                                                                                                        protected readonly onDidExecuteCommandEmitter: Emitter<CommandEvent>;

                                                                                                                                                                                          property onWillExecuteCommand

                                                                                                                                                                                          readonly onWillExecuteCommand: Event<WillExecuteCommandEvent>;

                                                                                                                                                                                            property onWillExecuteCommandEmitter

                                                                                                                                                                                            protected readonly onWillExecuteCommandEmitter: Emitter<WillExecuteCommandEvent>;

                                                                                                                                                                                              property recent

                                                                                                                                                                                              recent: Command[];
                                                                                                                                                                                              • Get the list of recently used commands.

                                                                                                                                                                                              property toUnregisterCommands

                                                                                                                                                                                              protected readonly toUnregisterCommands: Map<string, Disposable>;

                                                                                                                                                                                                method addRecentCommand

                                                                                                                                                                                                addRecentCommand: (recent: Command | Command[]) => void;
                                                                                                                                                                                                • Adds a command to recently used list. Prioritizes commands that were recently executed to be most recent.

                                                                                                                                                                                                  Parameter recent

                                                                                                                                                                                                  a recent command, or array of recent commands.

                                                                                                                                                                                                method clearCommandHistory

                                                                                                                                                                                                clearCommandHistory: () => void;
                                                                                                                                                                                                • Clear the list of recently used commands.

                                                                                                                                                                                                method doFireDidChange

                                                                                                                                                                                                protected doFireDidChange: () => void;

                                                                                                                                                                                                  method doRegisterCommand

                                                                                                                                                                                                  protected doRegisterCommand: (command: Command) => Disposable;

                                                                                                                                                                                                    method executeCommand

                                                                                                                                                                                                    executeCommand: <T>(commandId: string, ...args: any[]) => Promise<T | undefined>;
                                                                                                                                                                                                    • Execute the active handler for the given command and arguments.

                                                                                                                                                                                                      Reject if a command cannot be executed.

                                                                                                                                                                                                    method fireWillExecuteCommand

                                                                                                                                                                                                    protected fireWillExecuteCommand: (
                                                                                                                                                                                                    commandId: string,
                                                                                                                                                                                                    args?: any[]
                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                      method getActiveHandler

                                                                                                                                                                                                      getActiveHandler: (
                                                                                                                                                                                                      commandId: string,
                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                      ) => CommandHandler | undefined;
                                                                                                                                                                                                      • Get an active handler for the given command or undefined.

                                                                                                                                                                                                      method getAllCommands

                                                                                                                                                                                                      getAllCommands: () => IterableIterator<
                                                                                                                                                                                                      Readonly<Command & { handlers: CommandHandler[] }>
                                                                                                                                                                                                      >;

                                                                                                                                                                                                        method getAllHandlers

                                                                                                                                                                                                        getAllHandlers: (commandId: string) => CommandHandler[];
                                                                                                                                                                                                        • Returns with all handlers for the given command. If the command does not have any handlers, or the command is not registered, returns an empty array.

                                                                                                                                                                                                        method getCommand

                                                                                                                                                                                                        getCommand: (id: string) => Command | undefined;
                                                                                                                                                                                                        • Get a command for the given command identifier.

                                                                                                                                                                                                        method getToggledHandler

                                                                                                                                                                                                        getToggledHandler: (
                                                                                                                                                                                                        commandId: string,
                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                        ) => CommandHandler | undefined;
                                                                                                                                                                                                        • Get a toggled handler for the given command or undefined.

                                                                                                                                                                                                        method getVisibleHandler

                                                                                                                                                                                                        getVisibleHandler: (
                                                                                                                                                                                                        commandId: string,
                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                        ) => CommandHandler | undefined;
                                                                                                                                                                                                        • Get a visible handler for the given command or undefined.

                                                                                                                                                                                                        method isEnabled

                                                                                                                                                                                                        isEnabled: (command: string, ...args: any[]) => boolean;
                                                                                                                                                                                                        • Test whether there is an active handler for the given command.

                                                                                                                                                                                                        method isToggled

                                                                                                                                                                                                        isToggled: (command: string, ...args: any[]) => boolean;
                                                                                                                                                                                                        • Test whether there is a toggled handler for the given command.

                                                                                                                                                                                                        method isVisible

                                                                                                                                                                                                        isVisible: (command: string, ...args: any[]) => boolean;
                                                                                                                                                                                                        • Test whether there is a visible handler for the given command.

                                                                                                                                                                                                        method onStart

                                                                                                                                                                                                        onStart: () => void;

                                                                                                                                                                                                          method registerCommand

                                                                                                                                                                                                          registerCommand: (command: Command, handler?: CommandHandler) => Disposable;
                                                                                                                                                                                                          • Register the given command and handler if present.

                                                                                                                                                                                                            Throw if a command is already registered for the given command identifier.

                                                                                                                                                                                                          method registerHandler

                                                                                                                                                                                                          registerHandler: (commandId: string, handler: CommandHandler) => Disposable;
                                                                                                                                                                                                          • Register the given handler for the given command identifier.

                                                                                                                                                                                                            If there is already a handler for the given command then the given handler is registered as more specific, and has higher priority during enablement, visibility and toggle state evaluations.

                                                                                                                                                                                                          method unregisterCommand

                                                                                                                                                                                                          unregisterCommand: { (command: Command): void; (id: string): void };
                                                                                                                                                                                                          • Unregister command from the registry

                                                                                                                                                                                                            Parameter command

                                                                                                                                                                                                          • Unregister command from the registry

                                                                                                                                                                                                            Parameter id

                                                                                                                                                                                                          class CompositeMenuNode

                                                                                                                                                                                                          class CompositeMenuNode implements MenuNode {}
                                                                                                                                                                                                          • Node representing a (sub)menu in the menu tree structure.

                                                                                                                                                                                                          constructor

                                                                                                                                                                                                          constructor(id: string, label?: string, options?: SubMenuOptions);

                                                                                                                                                                                                            property children

                                                                                                                                                                                                            readonly children: readonly MenuNode[];

                                                                                                                                                                                                              property iconClass

                                                                                                                                                                                                              iconClass?: string;

                                                                                                                                                                                                                property id

                                                                                                                                                                                                                readonly id: string;

                                                                                                                                                                                                                  property isSubmenu

                                                                                                                                                                                                                  readonly isSubmenu: boolean;

                                                                                                                                                                                                                    property label

                                                                                                                                                                                                                    label?: string;

                                                                                                                                                                                                                      property order

                                                                                                                                                                                                                      order?: string;

                                                                                                                                                                                                                        property sortString

                                                                                                                                                                                                                        readonly sortString: string;

                                                                                                                                                                                                                          method addNode

                                                                                                                                                                                                                          addNode: (node: MenuNode) => Disposable;
                                                                                                                                                                                                                          • Inserts the given node at the position indicated by sortString.

                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                            a disposable which, when called, will remove the given node again.

                                                                                                                                                                                                                          method isNavigationGroup

                                                                                                                                                                                                                          static isNavigationGroup: (node: MenuNode) => node is CompositeMenuNode;
                                                                                                                                                                                                                          • Indicates whether the given node is the special navigation menu.

                                                                                                                                                                                                                            Parameter node

                                                                                                                                                                                                                            the menu node to check.

                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                            true when the given node is a CompositeMenuNode with id navigation, false otherwise.

                                                                                                                                                                                                                          method removeNode

                                                                                                                                                                                                                          removeNode: (id: string) => void;
                                                                                                                                                                                                                          • Removes the first node with the given id.

                                                                                                                                                                                                                            Parameter id

                                                                                                                                                                                                                            node id.

                                                                                                                                                                                                                          class ConnectionErrorHandler

                                                                                                                                                                                                                          class ConnectionErrorHandler {}

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor(options: ConnectionErrorHandlerOptions);

                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                              protected readonly options: ResolvedConnectionErrorHandlerOptions;

                                                                                                                                                                                                                                property restarts

                                                                                                                                                                                                                                protected readonly restarts: number[];

                                                                                                                                                                                                                                  method shouldRestart

                                                                                                                                                                                                                                  shouldRestart: () => boolean;

                                                                                                                                                                                                                                    method shouldStop

                                                                                                                                                                                                                                    shouldStop: (error: Error, message?: Message, count?: number) => boolean;

                                                                                                                                                                                                                                      class ContributionFilterRegistryImpl

                                                                                                                                                                                                                                      class ContributionFilterRegistryImpl implements ContributionFilterRegistry {}
                                                                                                                                                                                                                                      • Registry of contribution filters.

                                                                                                                                                                                                                                        Implement/bind to the FilterContribution interface/symbol to register your contribution filters.

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(contributions?: FilterContribution[]);

                                                                                                                                                                                                                                        property genericFilters

                                                                                                                                                                                                                                        protected genericFilters: Filter<Object>[];

                                                                                                                                                                                                                                          property initialized

                                                                                                                                                                                                                                          protected initialized: boolean;

                                                                                                                                                                                                                                            property typeToFilters

                                                                                                                                                                                                                                            protected typeToFilters: Map<
                                                                                                                                                                                                                                            interfaces.ServiceIdentifier<any>,
                                                                                                                                                                                                                                            Filter<Object>[]
                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                              method addFilters

                                                                                                                                                                                                                                              addFilters: (types: '*' | ContributionType[], filters: Filter<Object>[]) => void;

                                                                                                                                                                                                                                                method applyFilters

                                                                                                                                                                                                                                                applyFilters: <T extends Object>(
                                                                                                                                                                                                                                                toFilter: T[],
                                                                                                                                                                                                                                                type: interfaces.ServiceIdentifier<any>
                                                                                                                                                                                                                                                ) => T[];

                                                                                                                                                                                                                                                  method getFilters

                                                                                                                                                                                                                                                  protected getFilters: (
                                                                                                                                                                                                                                                  type: interfaces.ServiceIdentifier<any>
                                                                                                                                                                                                                                                  ) => Filter<Object>[];

                                                                                                                                                                                                                                                    method getOrCreate

                                                                                                                                                                                                                                                    protected getOrCreate: (
                                                                                                                                                                                                                                                    type: interfaces.ServiceIdentifier<any>
                                                                                                                                                                                                                                                    ) => Filter<Object>[];

                                                                                                                                                                                                                                                      class DefaultBackendStopwatch

                                                                                                                                                                                                                                                      class DefaultBackendStopwatch {}
                                                                                                                                                                                                                                                      • Default implementation of the (remote) back-end stopwatch service.

                                                                                                                                                                                                                                                      property idSequence

                                                                                                                                                                                                                                                      protected idSequence: number;

                                                                                                                                                                                                                                                        property measurements

                                                                                                                                                                                                                                                        readonly measurements: Map<number, Measurement>;

                                                                                                                                                                                                                                                          property stopwatch

                                                                                                                                                                                                                                                          protected readonly stopwatch: Stopwatch;

                                                                                                                                                                                                                                                            method start

                                                                                                                                                                                                                                                            start: (name: string, options?: MeasurementOptions) => RemoteMeasurement;

                                                                                                                                                                                                                                                              method stop

                                                                                                                                                                                                                                                              stop: (
                                                                                                                                                                                                                                                              measurementToken: RemoteMeasurement,
                                                                                                                                                                                                                                                              message: string,
                                                                                                                                                                                                                                                              messageArgs: any[]
                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                class DefaultResourceProvider

                                                                                                                                                                                                                                                                class DefaultResourceProvider {}

                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                  constructor(resolversProvider: ContributionProvider<ResourceResolver>);

                                                                                                                                                                                                                                                                    property resolversProvider

                                                                                                                                                                                                                                                                    protected readonly resolversProvider: ContributionProvider<ResourceResolver>;

                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                      get: (uri: URI) => Promise<Resource>;
                                                                                                                                                                                                                                                                      • Reject if a resource cannot be provided.

                                                                                                                                                                                                                                                                      class DisposableCollection

                                                                                                                                                                                                                                                                      class DisposableCollection implements Disposable {}

                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                        constructor(...toDispose: Disposable[]);

                                                                                                                                                                                                                                                                          property disposables

                                                                                                                                                                                                                                                                          protected readonly disposables: Disposable[];

                                                                                                                                                                                                                                                                            property disposed

                                                                                                                                                                                                                                                                            readonly disposed: boolean;

                                                                                                                                                                                                                                                                              property onDispose

                                                                                                                                                                                                                                                                              readonly onDispose: Event<void>;
                                                                                                                                                                                                                                                                              • This event is fired only once on first dispose of not empty collection.

                                                                                                                                                                                                                                                                              property onDisposeEmitter

                                                                                                                                                                                                                                                                              protected readonly onDisposeEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                method checkDisposed

                                                                                                                                                                                                                                                                                protected checkDisposed: () => void;

                                                                                                                                                                                                                                                                                  method dispose

                                                                                                                                                                                                                                                                                  dispose: () => void;

                                                                                                                                                                                                                                                                                    method push

                                                                                                                                                                                                                                                                                    push: (disposable: Disposable) => Disposable;

                                                                                                                                                                                                                                                                                      method pushAll

                                                                                                                                                                                                                                                                                      pushAll: (disposables: Disposable[]) => Disposable[];

                                                                                                                                                                                                                                                                                        class Emitter

                                                                                                                                                                                                                                                                                        class Emitter<T = any> {}

                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                          constructor(_options?: EmitterOptions);

                                                                                                                                                                                                                                                                                            property event

                                                                                                                                                                                                                                                                                            readonly event: Event<T>;
                                                                                                                                                                                                                                                                                            • For the public to allow to subscribe to events from this Emitter

                                                                                                                                                                                                                                                                                            method checkMaxListeners

                                                                                                                                                                                                                                                                                            protected checkMaxListeners: (maxListeners: number) => (() => void) | undefined;

                                                                                                                                                                                                                                                                                              method dispose

                                                                                                                                                                                                                                                                                              dispose: () => void;

                                                                                                                                                                                                                                                                                                method fire

                                                                                                                                                                                                                                                                                                fire: (event: T) => any;
                                                                                                                                                                                                                                                                                                • To be kept private to fire an event to subscribers

                                                                                                                                                                                                                                                                                                method popLeakingStack

                                                                                                                                                                                                                                                                                                protected popLeakingStack: (stack: string) => void;

                                                                                                                                                                                                                                                                                                  method pushLeakingStack

                                                                                                                                                                                                                                                                                                  protected pushLeakingStack: () => () => void;

                                                                                                                                                                                                                                                                                                    method sequence

                                                                                                                                                                                                                                                                                                    sequence: (
                                                                                                                                                                                                                                                                                                    processor: (listener: (e: T) => any) => MaybePromise<boolean>
                                                                                                                                                                                                                                                                                                    ) => Promise<void>;
                                                                                                                                                                                                                                                                                                    • Process each listener one by one. Return false to stop iterating over the listeners, true to continue.

                                                                                                                                                                                                                                                                                                    class InMemoryResources

                                                                                                                                                                                                                                                                                                    class InMemoryResources implements ResourceResolver {}

                                                                                                                                                                                                                                                                                                      property resources

                                                                                                                                                                                                                                                                                                      protected readonly resources: SyncReferenceCollection<string, MutableResource>;

                                                                                                                                                                                                                                                                                                        method acquire

                                                                                                                                                                                                                                                                                                        protected acquire: (uri: string) => ReferenceMutableResource;

                                                                                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                                                                                          add: (uri: URI, contents: string) => Resource;

                                                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                                                            resolve: (uri: URI) => Resource;

                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                              update: (uri: URI, contents: string) => Resource;

                                                                                                                                                                                                                                                                                                                class InMemoryTextResource

                                                                                                                                                                                                                                                                                                                class InMemoryTextResource implements Resource {}
                                                                                                                                                                                                                                                                                                                • Resource implementation for 'mem-txt' URI scheme where content is saved in URI query.

                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                constructor(uri: URI);

                                                                                                                                                                                                                                                                                                                  property uri

                                                                                                                                                                                                                                                                                                                  readonly uri: URI;

                                                                                                                                                                                                                                                                                                                    method dispose

                                                                                                                                                                                                                                                                                                                    dispose: () => void;

                                                                                                                                                                                                                                                                                                                      method readContents

                                                                                                                                                                                                                                                                                                                      readContents: (
                                                                                                                                                                                                                                                                                                                      options?: { encoding?: string | undefined } | undefined
                                                                                                                                                                                                                                                                                                                      ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                        class InMemoryTextResourceResolver

                                                                                                                                                                                                                                                                                                                        class InMemoryTextResourceResolver implements ResourceResolver {}
                                                                                                                                                                                                                                                                                                                        • ResourceResolver implementation for 'mem-txt' URI scheme.

                                                                                                                                                                                                                                                                                                                        method resolve

                                                                                                                                                                                                                                                                                                                        resolve: (uri: URI) => MaybePromise<Resource>;

                                                                                                                                                                                                                                                                                                                          class JsonRpcConnectionHandler

                                                                                                                                                                                                                                                                                                                          class JsonRpcConnectionHandler<T extends object> implements ConnectionHandler {}

                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                            path: string,
                                                                                                                                                                                                                                                                                                                            targetFactory: (proxy: JsonRpcProxy<T>) => any,
                                                                                                                                                                                                                                                                                                                            factoryConstructor?: new () => JsonRpcProxyFactory<T>
                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                              property factoryConstructor

                                                                                                                                                                                                                                                                                                                              readonly factoryConstructor: new () => JsonRpcProxyFactory<T>;

                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                readonly path: string;

                                                                                                                                                                                                                                                                                                                                  property targetFactory

                                                                                                                                                                                                                                                                                                                                  readonly targetFactory: (proxy: JsonRpcProxy<T>) => any;

                                                                                                                                                                                                                                                                                                                                    method onConnection

                                                                                                                                                                                                                                                                                                                                    onConnection: (connection: MessageConnection) => void;

                                                                                                                                                                                                                                                                                                                                      class JsonRpcProxyFactory

                                                                                                                                                                                                                                                                                                                                      class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {}
                                                                                                                                                                                                                                                                                                                                      • Factory for JSON-RPC proxy objects.

                                                                                                                                                                                                                                                                                                                                        A JSON-RPC proxy exposes the programmatic interface of an object through JSON-RPC. This allows remote programs to call methods of this objects by sending JSON-RPC requests. This takes place over a bi-directional stream, where both ends can expose an object and both can call methods each other's exposed object.

                                                                                                                                                                                                                                                                                                                                        For example, assuming we have an object of the following type on one end:

                                                                                                                                                                                                                                                                                                                                        class Foo { bar(baz: number): number { return baz + 1 } }

                                                                                                                                                                                                                                                                                                                                        which we want to expose through a JSON-RPC interface. We would do:

                                                                                                                                                                                                                                                                                                                                        let target = new Foo() let factory = new JsonRpcProxyFactory('/foo', target) factory.onConnection(connection)

                                                                                                                                                                                                                                                                                                                                        The party at the other end of the connection, in order to remotely call methods on this object would do:

                                                                                                                                                                                                                                                                                                                                        let factory = new JsonRpcProxyFactory('/foo') factory.onConnection(connection) let proxy = factory.createProxy(); let result = proxy.bar(42) // result is equal to 43

                                                                                                                                                                                                                                                                                                                                        One the wire, it would look like this:

                                                                                                                                                                                                                                                                                                                                        --> {"jsonrpc": "2.0", "id": 0, "method": "bar", "params": {"baz": 42}} <-- {"jsonrpc": "2.0", "id": 0, "result": 43}

                                                                                                                                                                                                                                                                                                                                        Note that in the code of the caller, we didn't pass a target object to JsonRpcProxyFactory, because we don't want/need to expose an object. If we had passed a target object, the other side could've called methods on it.

                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                        - The type of the object to expose to JSON-RPC.

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(target?: any);
                                                                                                                                                                                                                                                                                                                                      • Build a new JsonRpcProxyFactory.

                                                                                                                                                                                                                                                                                                                                        Parameter target

                                                                                                                                                                                                                                                                                                                                        The object to expose to JSON-RPC methods calls. If this is omitted, the proxy won't be able to handle requests, only send them.

                                                                                                                                                                                                                                                                                                                                      property connectionPromise

                                                                                                                                                                                                                                                                                                                                      protected connectionPromise: Promise<MessageConnection>;

                                                                                                                                                                                                                                                                                                                                        property connectionPromiseResolve

                                                                                                                                                                                                                                                                                                                                        protected connectionPromiseResolve: (connection: MessageConnection) => void;

                                                                                                                                                                                                                                                                                                                                          property onDidCloseConnectionEmitter

                                                                                                                                                                                                                                                                                                                                          protected readonly onDidCloseConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                            property onDidOpenConnectionEmitter

                                                                                                                                                                                                                                                                                                                                            protected readonly onDidOpenConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                              property target

                                                                                                                                                                                                                                                                                                                                              target?: any;

                                                                                                                                                                                                                                                                                                                                                method createProxy

                                                                                                                                                                                                                                                                                                                                                createProxy: () => JsonRpcProxy<T>;
                                                                                                                                                                                                                                                                                                                                                • Create a Proxy exposing the interface of an object of type T. This Proxy can be used to do JSON-RPC method calls on the remote target object as if it was local.

                                                                                                                                                                                                                                                                                                                                                  If T implements JsonRpcServer then a client is used as a target object for a remote target object.

                                                                                                                                                                                                                                                                                                                                                method deserializeError

                                                                                                                                                                                                                                                                                                                                                protected deserializeError: (capturedError: Error, e: any) => any;

                                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                                  get: (target: T, p: PropertyKey, receiver: any) => any;
                                                                                                                                                                                                                                                                                                                                                  • Get a callable object that executes a JSON-RPC method call.

                                                                                                                                                                                                                                                                                                                                                    Getting a property on the Proxy object returns a callable that, when called, executes a JSON-RPC call. The name of the property defines the method to be called. The callable takes a variable number of arguments, which are passed in the JSON-RPC method call.

                                                                                                                                                                                                                                                                                                                                                    For example, if you have a Proxy object:

                                                                                                                                                                                                                                                                                                                                                    let fooProxyFactory = JsonRpcProxyFactory('/foo') let fooProxy = fooProxyFactory.createProxy()

                                                                                                                                                                                                                                                                                                                                                    accessing fooProxy.bar will return a callable that, when called, executes a JSON-RPC method call to method bar. Therefore, doing fooProxy.bar() will call the bar method on the remote Foo object.

                                                                                                                                                                                                                                                                                                                                                    Parameter target

                                                                                                                                                                                                                                                                                                                                                    unused.

                                                                                                                                                                                                                                                                                                                                                    Parameter p

                                                                                                                                                                                                                                                                                                                                                    The property accessed on the Proxy object.

                                                                                                                                                                                                                                                                                                                                                    Parameter receiver

                                                                                                                                                                                                                                                                                                                                                    unused.

                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                    A callable that executes the JSON-RPC call.

                                                                                                                                                                                                                                                                                                                                                  method isNotification

                                                                                                                                                                                                                                                                                                                                                  protected isNotification: (p: PropertyKey) => boolean;
                                                                                                                                                                                                                                                                                                                                                  • Return whether the given property represents a notification.

                                                                                                                                                                                                                                                                                                                                                    A property leads to a notification rather than a method call if its name begins with notify or on.

                                                                                                                                                                                                                                                                                                                                                    Parameter p

                                                                                                                                                                                                                                                                                                                                                    The property being called on the proxy. Whether p represents a notification.

                                                                                                                                                                                                                                                                                                                                                  method listen

                                                                                                                                                                                                                                                                                                                                                  listen: (connection: MessageConnection) => void;
                                                                                                                                                                                                                                                                                                                                                  • Connect a MessageConnection to the factory.

                                                                                                                                                                                                                                                                                                                                                    This connection will be used to send/receive JSON-RPC requests and response.

                                                                                                                                                                                                                                                                                                                                                  method onNotification

                                                                                                                                                                                                                                                                                                                                                  protected onNotification: (method: string, ...args: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                  • Process an incoming JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                    Same as [[onRequest]], but called on incoming notifications rather than methods calls.

                                                                                                                                                                                                                                                                                                                                                  method onRequest

                                                                                                                                                                                                                                                                                                                                                  protected onRequest: (method: string, ...args: any[]) => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                  • Process an incoming JSON-RPC method call.

                                                                                                                                                                                                                                                                                                                                                    onRequest is called when the JSON-RPC connection received a method call request. It calls the corresponding method on [[target]].

                                                                                                                                                                                                                                                                                                                                                    The return value is a Promise object that is resolved with the return value of the method call, if it is successful. The promise is rejected if the called method does not exist or if it throws.

                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                    A promise of the method call completion.

                                                                                                                                                                                                                                                                                                                                                  method serializeError

                                                                                                                                                                                                                                                                                                                                                  protected serializeError: (e: any) => any;

                                                                                                                                                                                                                                                                                                                                                    method waitForConnection

                                                                                                                                                                                                                                                                                                                                                    protected waitForConnection: () => void;

                                                                                                                                                                                                                                                                                                                                                      class Logger

                                                                                                                                                                                                                                                                                                                                                      class Logger implements ILogger {}

                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                        server: ILoggerServer,
                                                                                                                                                                                                                                                                                                                                                        loggerWatcher: LoggerWatcher,
                                                                                                                                                                                                                                                                                                                                                        factory: LoggerFactory,
                                                                                                                                                                                                                                                                                                                                                        name: string
                                                                                                                                                                                                                                                                                                                                                        );
                                                                                                                                                                                                                                                                                                                                                        • Build a new Logger.

                                                                                                                                                                                                                                                                                                                                                        property created

                                                                                                                                                                                                                                                                                                                                                        protected created: Promise<void>;

                                                                                                                                                                                                                                                                                                                                                          property factory

                                                                                                                                                                                                                                                                                                                                                          protected readonly factory: LoggerFactory;

                                                                                                                                                                                                                                                                                                                                                            property loggerWatcher

                                                                                                                                                                                                                                                                                                                                                            protected readonly loggerWatcher: LoggerWatcher;

                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                              protected name: string;

                                                                                                                                                                                                                                                                                                                                                                property server

                                                                                                                                                                                                                                                                                                                                                                protected readonly server: ILoggerServer;

                                                                                                                                                                                                                                                                                                                                                                  method child

                                                                                                                                                                                                                                                                                                                                                                  child: (name: string) => ILogger;

                                                                                                                                                                                                                                                                                                                                                                    method debug

                                                                                                                                                                                                                                                                                                                                                                    debug: (arg: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                      method error

                                                                                                                                                                                                                                                                                                                                                                      error: (arg: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        method fatal

                                                                                                                                                                                                                                                                                                                                                                        fatal: (arg: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                          method format

                                                                                                                                                                                                                                                                                                                                                                          protected format: (value: any) => any;

                                                                                                                                                                                                                                                                                                                                                                            method getLog

                                                                                                                                                                                                                                                                                                                                                                            protected getLog: (logLevel: number) => Promise<Log>;

                                                                                                                                                                                                                                                                                                                                                                              method getLogLevel

                                                                                                                                                                                                                                                                                                                                                                              getLogLevel: () => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                method ifDebug

                                                                                                                                                                                                                                                                                                                                                                                ifDebug: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                  method ifEnabled

                                                                                                                                                                                                                                                                                                                                                                                  ifEnabled: (logLevel: number) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method ifError

                                                                                                                                                                                                                                                                                                                                                                                    ifError: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                      method ifFatal

                                                                                                                                                                                                                                                                                                                                                                                      ifFatal: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                        method ifInfo

                                                                                                                                                                                                                                                                                                                                                                                        ifInfo: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                          method ifTrace

                                                                                                                                                                                                                                                                                                                                                                                          ifTrace: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                            method ifWarn

                                                                                                                                                                                                                                                                                                                                                                                            ifWarn: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                              method info

                                                                                                                                                                                                                                                                                                                                                                                              info: (arg: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                method isDebug

                                                                                                                                                                                                                                                                                                                                                                                                isDebug: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                  method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                  isEnabled: (logLevel: number) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                    method isError

                                                                                                                                                                                                                                                                                                                                                                                                    isError: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                      method isFatal

                                                                                                                                                                                                                                                                                                                                                                                                      isFatal: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                        method isInfo

                                                                                                                                                                                                                                                                                                                                                                                                        isInfo: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                          method isTrace

                                                                                                                                                                                                                                                                                                                                                                                                          isTrace: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                            method isWarn

                                                                                                                                                                                                                                                                                                                                                                                                            isWarn: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                              method log

                                                                                                                                                                                                                                                                                                                                                                                                              log: (logLevel: number, arg2: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                method setLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                setLogLevel: (logLevel: number) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                  method trace

                                                                                                                                                                                                                                                                                                                                                                                                                  trace: (arg: any | Loggable, ...params: any[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                    method warn

                                                                                                                                                                                                                                                                                                                                                                                                                    warn: (arg: any | Loggable, ...params: any[]) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                      class MenuModelRegistry {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • The MenuModelRegistry allows to register and unregister menus, submenus and actions via strings and MenuActions without the need to access the underlying UI representation.

                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                      contributions: ContributionProvider<MenuContribution>,
                                                                                                                                                                                                                                                                                                                                                                                                                      commands: CommandRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                      );
                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly commands: CommandRegistry;
                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly contributions: ContributionProvider<MenuContribution>;
                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly root: CompositeMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                              protected findGroup: (
                                                                                                                                                                                                                                                                                                                                                                                                                              menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                              options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => CompositeMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                protected findSubMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                current: CompositeMenuNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                menuId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => CompositeMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                  getMenu: (menuPath?: MenuPath) => CompositeMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the menu at the given path.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                    the path specifying the menu to return. If not given the empty path will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                    the root menu when menuPath is empty. If menuPath is not empty the specified menu is returned if it exists, otherwise an error is thrown.

                                                                                                                                                                                                                                                                                                                                                                                                                                  onStart: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    registerMenuAction: (menuPath: MenuPath, item: MenuAction) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Adds the given menu action to the menu denoted by the given path.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                      a disposable which, when called, will remove the menu action again.

                                                                                                                                                                                                                                                                                                                                                                                                                                    registerMenuNode: (menuPath: MenuPath, menuNode: MenuNode) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Adds the given menu node to the menu denoted by the given path.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                      a disposable which, when called, will remove the menu node again.

                                                                                                                                                                                                                                                                                                                                                                                                                                    registerSubmenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                    label: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Register a new menu at the given path with the given label. (If the menu already exists without a label, iconClass or order this method can be used to set them.)

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                      the path for which a new submenu shall be registered.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter label

                                                                                                                                                                                                                                                                                                                                                                                                                                      the label to be used for the new submenu.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                      optionally allows to set an icon class and specify the order of the new menu.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                      if the menu was successfully created a disposable will be returned which, when called, will remove the menu again. If the menu already existed a no-op disposable will be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Note that if the menu already existed and was registered with a different label an error will be thrown.

                                                                                                                                                                                                                                                                                                                                                                                                                                    unregisterMenuAction: {
                                                                                                                                                                                                                                                                                                                                                                                                                                    (item: MenuAction, menuPath?: MenuPath): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    (command: Command, menuPath?: MenuPath): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    (id: string, menuPath?: MenuPath): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unregister all menu nodes with the same id as the given menu action.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter item

                                                                                                                                                                                                                                                                                                                                                                                                                                      the item whose id will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                      if specified only nodes within the path will be unregistered.

                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unregister all menu nodes with the same id as the given command.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter command

                                                                                                                                                                                                                                                                                                                                                                                                                                      the command whose id will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                      if specified only nodes within the path will be unregistered.

                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unregister all menu nodes with the given id.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter id

                                                                                                                                                                                                                                                                                                                                                                                                                                      the id which shall be removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                      if specified only nodes within the path will be unregistered.

                                                                                                                                                                                                                                                                                                                                                                                                                                    unregisterMenuNode: (id: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Recurse all menus, removing any menus matching the id.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter id

                                                                                                                                                                                                                                                                                                                                                                                                                                      technical identifier of the MenuNode.

                                                                                                                                                                                                                                                                                                                                                                                                                                    class MessageClient

                                                                                                                                                                                                                                                                                                                                                                                                                                    class MessageClient {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method reportProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                      reportProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      progressId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                      update: ProgressUpdate,
                                                                                                                                                                                                                                                                                                                                                                                                                                      message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                      cancellationToken: CancellationToken
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Update a previously created progress message.

                                                                                                                                                                                                                                                                                                                                                                                                                                        To be implemented by an extension, e.g. by the messages extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                      method showMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                      showMessage: (message: Message) => Promise<string | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Show a message of the given type and possible actions to the user. Resolve to a chosen action. Never reject.

                                                                                                                                                                                                                                                                                                                                                                                                                                        To be implemented by an extension, e.g. by the messages extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                      method showProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                      showProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      progressId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                      message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                      cancellationToken: CancellationToken
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<string | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Show a progress message with possible actions to user.

                                                                                                                                                                                                                                                                                                                                                                                                                                        To be implemented by an extension, e.g. by the messages extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                      class MessageService

                                                                                                                                                                                                                                                                                                                                                                                                                                      class MessageService {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Service to log and categorize messages, show progress information and offer actions.

                                                                                                                                                                                                                                                                                                                                                                                                                                        The messages are processed by this service and forwarded to an injected MessageClient. For example "@theia/messages" provides such a client, rendering messages as notifications in the frontend.

                                                                                                                                                                                                                                                                                                                                                                                                                                        ### Example usage

                                                                                                                                                                                                                                                                                                                                                                                                                                        @inject(MessageService)
                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly messageService: MessageService;
                                                                                                                                                                                                                                                                                                                                                                                                                                        messageService.warn("Typings not available");
                                                                                                                                                                                                                                                                                                                                                                                                                                        messageService.error("Could not restore state", ["Rollback", "Ignore"])
                                                                                                                                                                                                                                                                                                                                                                                                                                        .then(action => action === "Rollback" && rollback());

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(client: MessageClient);

                                                                                                                                                                                                                                                                                                                                                                                                                                        property client

                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly client: MessageClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method error

                                                                                                                                                                                                                                                                                                                                                                                                                                          error: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                          message: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: MessageOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                          ...actions: T[]
                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message as "error" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message as "error" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                            additional options. Can be omitted

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method info

                                                                                                                                                                                                                                                                                                                                                                                                                                          info: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                          message: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: MessageOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                          ...actions: T[]
                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message as "info" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message as "info" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                            additional options. Can be omitted

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method log

                                                                                                                                                                                                                                                                                                                                                                                                                                          log: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                          message: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: MessageOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                          ...actions: T[]
                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Logs the message and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                            the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                            additional options. Can be omitted

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                            the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                            the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method newProgressId

                                                                                                                                                                                                                                                                                                                                                                                                                                          protected newProgressId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method processMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                            protected processMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            type: MessageType,
                                                                                                                                                                                                                                                                                                                                                                                                                                            text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                            args?: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<string | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method showProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                              showProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                              onDidCancel?: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<Progress>;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Shows the given message as a progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                the message to show for the progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter onDidCancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                an optional callback which will be invoked if the progress indicator was canceled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                a promise resolving to a Progress object with which the progress can be updated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                ### Example usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                @inject(MessageService)
                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly messageService: MessageService;
                                                                                                                                                                                                                                                                                                                                                                                                                                                // this will show "Progress" as a cancelable message
                                                                                                                                                                                                                                                                                                                                                                                                                                                this.messageService.showProgress({text: 'Progress'});
                                                                                                                                                                                                                                                                                                                                                                                                                                                // this will show "Rolling back" with "Cancel" and an additional "Skip" action
                                                                                                                                                                                                                                                                                                                                                                                                                                                this.messageService.showProgress({
                                                                                                                                                                                                                                                                                                                                                                                                                                                text: `Rolling back`,
                                                                                                                                                                                                                                                                                                                                                                                                                                                actions: ["Skip"],
                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                () => console.log("canceled"))
                                                                                                                                                                                                                                                                                                                                                                                                                                                .then((progress) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                // register if interested in the result (only necessary for custom actions)
                                                                                                                                                                                                                                                                                                                                                                                                                                                progress.result.then((result) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                // will be 'Cancel', 'Skip' or `undefined`
                                                                                                                                                                                                                                                                                                                                                                                                                                                console.log("result is", result);
                                                                                                                                                                                                                                                                                                                                                                                                                                                });
                                                                                                                                                                                                                                                                                                                                                                                                                                                progress.report({message: "Cleaning references", work: {done: 10, total: 100}});
                                                                                                                                                                                                                                                                                                                                                                                                                                                progress.report({message: "Restoring previous state", work: {done: 80, total: 100}});
                                                                                                                                                                                                                                                                                                                                                                                                                                                progress.report({message: "Complete", work: {done: 100, total: 100}});
                                                                                                                                                                                                                                                                                                                                                                                                                                                // we are done so we can cancel the progress message, note that this will also invoke `onDidCancel`
                                                                                                                                                                                                                                                                                                                                                                                                                                                progress.cancel();
                                                                                                                                                                                                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                                                                                                                                                                                              method warn

                                                                                                                                                                                                                                                                                                                                                                                                                                              warn: {
                                                                                                                                                                                                                                                                                                                                                                                                                                              <T extends string>(message: string, ...actions: T[]): Promise<T | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                              <T extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                              message: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: MessageOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                              ...actions: T[]
                                                                                                                                                                                                                                                                                                                                                                                                                                              ): Promise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Logs the message as "warning" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                              • Logs the message as "warning" and, if given, offers actions to act on it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                the message to log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                additional options. Can be omitted

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                the actions to offer. Can be omitted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                the selected action if there is any, undefined when there was no action or none was selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                              class MutableResource

                                                                                                                                                                                                                                                                                                                                                                                                                                              class MutableResource implements Resource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(uri: URI);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly onDidChangeContents: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDidChangeContentsEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly onDidChangeContentsEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly uri: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                        dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method fireDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected fireDidChangeContents: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method readContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                            readContents: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method saveContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                              saveContents: (contents: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NullBackendStopwatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NullBackendStopwatch implements BackendStopwatch {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • No-op implementation of the (remote) back-end stopwatch service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                start: () => Promise<RemoteMeasurement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stop: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Path {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(raw: string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The raw should be normalized, meaning that only '/' is allowed as a path separator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property base

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly base: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly dir: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the parent directory if it exists (hasDir === true) or this otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly ext: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hasDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly hasDir: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns true if this has a parent directory, false otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _This implementation returns true if and only if this is not the root dir and there is a path separator in the raw path._

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isAbsolute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly isAbsolute: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly isRoot: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly root: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property separator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static separator: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method computeDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected computeDir: () => Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method computeRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected computeRoot: () => Path | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method fsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fsPath: (format?: Path.Format) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Converts the current path into a file system path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines the format of the path. If undefined, the format will be determined by the OS.backend.type value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A file system path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDrive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static isDrive: (segment: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEqualOrParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEqualOrParent: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method join

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            join: (...paths: string[]) => Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method normalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              normalize: () => Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method normalizeDrive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static normalizeDrive: (path: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • vscode-uri always normalizes drive letters to lower case: https://github.com/Microsoft/vscode-uri/blob/b1d3221579f97f28a839b6f996d76fc45e9964d8/src/index.ts#L1025 Theia path should be adjusted to this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method normalizePathSeparator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static normalizePathSeparator: (path: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Normalize path separator to use Path.separator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  candidate to normalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Normalized string path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method relative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                relative: (path: Path) => Path | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method relativity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  relativity: (path: Path) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolve: (...paths: string[]) => Path | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Parameter paths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      portions of a path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      a new Path if an absolute path can be computed from the segments passed in + this.raw If no absolute path can be computed, returns undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Processes the path segments passed in from right to left (reverse order) concatenating until an absolute path is found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method tildify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static tildify: (resourcePath: string, home: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tildify path, replacing home with ~ if user's home is present at the beginning of the path. This is a non-operation for Windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter resourcePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter home

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method untildify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static untildify: (resourcePath: string, home: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Untildify path, replacing ~ with home if ~ present at the beginning of the path. This is a non-operation for Windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter resourcePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter home

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method windowsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static windowsPath: (path: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Creates a windows path from the given path string. A windows path uses an upper case drive letter and backwards slashes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The input path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Windows style path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ProgressService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ProgressService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly client: ProgressClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property messageService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly messageService: MessageService;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method newProgressId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected newProgressId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method shouldDelegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected shouldDelegate: (message: ProgressMessage) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method showProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidCancel?: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<Progress>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method withProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  withProgress: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  locationId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  task: () => Promise<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ReferenceCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ReferenceCollection<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    V extends Disposable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > extends AbstractReferenceCollection<K, V> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(factory: (key: K) => MaybePromise<V>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly factory: (key: K) => MaybePromise<V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pendingValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly pendingValues: Map<string, MaybePromise<V>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method acquire

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acquire: (args: K) => Promise<Reference<V>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getOrCreateValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getOrCreateValue: (key: string, args: K) => Promise<V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ReferenceMutableResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ReferenceMutableResource implements Resource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(reference: Reference<MutableResource>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly onDidChangeContents: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected reference: Reference<MutableResource>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly uri: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method readContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readContents: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method saveContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              saveContents: (contents: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SelectionService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SelectionService implements SelectionProvider<Object | undefined> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Singleton service that is used to share the current selection globally in a Theia application. On each change of selection, subscribers are notified and receive the updated selection object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onSelectionChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly onSelectionChanged: Event<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onSelectionChangedEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly onSelectionChangedEmitter: Emitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selection: Object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Stopwatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract class Stopwatch {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected constructor(defaultLogOptions: LogOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly defaultLogOptions: LogOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly logger: ILogger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method atLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected atLevel: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            logOptions: LogOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            levelOverride?: LogLevel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optionalArgs?: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => LogOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createMeasurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected createMeasurement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              measurement: () => number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: MeasurementOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Measurement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected log: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                measurement: Measurement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activity: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: LogOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method logLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected logLevel: (elapsed: number, options?: Partial<LogOptions>) => LogLevel;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method mergeLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected mergeLogOptions: (logOptions?: Partial<LogOptions>) => LogOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract start: (name: string, options?: MeasurementOptions) => Measurement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Create a Measurement that will compute its elapsed time when logged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional configuration of the new measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a self-timing measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method startAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startAsync: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      computation: () => MaybePromise<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: MeasurementOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Wrap an asynchronous function in a Measurement that logs itself on completion. If obtaining and awaiting the computation runs too long according to the threshold set in the options, then the log message is a warning, otherwise a debug log.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the to wrap around the function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a description of what the function does, to be included in the log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter computation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a supplier of the asynchronous function to wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional addition configuration as for measure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the wrapped computation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SyncReferenceCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SyncReferenceCollection<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      V extends Disposable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > extends AbstractReferenceCollection<K, V> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(factory: (key: K) => V);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly factory: (key: K) => V;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method acquire

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acquire: (args: K) => Reference<V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getOrCreateValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getOrCreateValue: (key: string, args: K) => V;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource implements Resource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resources: Map<string, UntitledResource>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  uri: URI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly encoding: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly onDidChangeContents: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeContentsEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly onDidChangeContentsEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uri: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly version: ResourceVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fireDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected fireDidChangeContents: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method readContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readContents: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: { encoding?: string | undefined } | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method saveContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    saveContents: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    content: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: { encoding?: string; overwriteEncoding?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class UntitledResourceResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class UntitledResourceResolver implements ResourceResolver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly resources: Map<string, UntitledResource>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createUntitledResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createUntitledResource: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          content?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extension?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uri?: URI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<UntitledResource>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolve: (uri: URI) => Promise<UntitledResource>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ApplicationError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ApplicationError<C extends number, D> extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly code: C;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly data: D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJson: () => ApplicationError.Literal<D>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BackendStopwatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BackendStopwatch {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A service that exposes the back-end's Stopwatch to clients via the remote API. If you do not need this service then bind or re-bind the NullBackendStopwatch implementation to this service interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: MeasurementOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<RemoteMeasurement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Create a Measurement that will compute the time that elapsed on the back-end when logged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional configuration of the new measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a token identifying an unique self-timing measurement relative to the back-end's timeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      measurement: RemoteMeasurement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      message: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      messageArgs: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Stop a measurement previously and log in the back-end a measurement of its duration relative to the back-end's timeline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        token identifying a measurement previously

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a message to log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter messageArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional arguments to the message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CancellationToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CancellationToken {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isCancellationRequested

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly isCancellationRequested: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCancellationRequested

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly onCancellationRequested: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Command {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A command is a unique identifier of a function which can be executed by a user via a keyboard shortcut, a menu action or directly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property category

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            category?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A category of this command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property iconClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            iconClass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An icon class of this command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A unique identifier of this command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            label?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A label of this command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property originalCategory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            originalCategory?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property originalLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              originalLabel?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommandContribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommandContribution {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The command contribution should be implemented to register custom commands and handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method registerCommands

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerCommands: (commands: CommandRegistry) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Register commands and handlers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommandEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommandEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  args: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property commandId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    commandId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommandHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommandHandler {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A command handler is an implementation of a command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A command can have multiple handlers but they should be active in different contexts, otherwise first active will be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method execute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      execute: (...args: any[]) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Execute this handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Don't call it directly, use CommandService.executeCommand instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isEnabled: (...args: any[]) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Test whether this handler is enabled (active).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isToggled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isToggled: (...args: any[]) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Test whether menu items for this handler should be toggled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isVisible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isVisible: (...args: any[]) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Test whether menu items for this handler should be visible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommandService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommandService {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The command service should be used to execute commands.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDidExecuteCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly onDidExecuteCommand: Event<CommandEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • An event is emitted when a command was executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onWillExecuteCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly onWillExecuteCommand: Event<WillExecuteCommandEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • An event is emitted when a command is about to be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        It can be used to install or activate a command handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method executeCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      executeCommand: <T>(command: string, ...args: any[]) => Promise<T | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Execute the active handler for the given command and arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Reject if a command cannot be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectionHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onConnection: (connection: MessageConnection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContributionFilterRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContributionFilterRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addFilters: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (types: '*', filters: Filter<Object>[]): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              types: interfaces.ServiceIdentifier<any>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filters: Filter<Object>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add filters to be applied for every type of contribution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Given a list of contribution types, register filters to apply.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                types for which to register the filters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method applyFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              applyFilters: <T extends Object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toFilter: T[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: interfaces.ServiceIdentifier<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Applies the filters for the given contribution type. Generic filters will be applied on any given type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter toFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                the elements to filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                the contribution type for which potentially filters were registered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                the filtered elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContributionProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContributionProvider<T extends object> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getContributions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getContributions: (recursive?: boolean) => T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Parameter recursive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  true if the contributions should be collected from the parent containers as well. Otherwise, false. It is false by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Disposable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Disposable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dispose: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Dispose this object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EmitterOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EmitterOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onFirstListenerAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onFirstListenerAdd?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onLastListenerRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLastListenerRemove?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Event<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents a typed event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        listener: (e: T) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        thisArgs?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disposables?: DisposableGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Parameter listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The listener function will be call when the event happens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter thisArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The 'this' which will be used when calling the event listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter disposables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An array to which a {{IDisposable}} will be added. a disposable to remove the listener again.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FilterContribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FilterContribution {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register filters to remove contributions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method registerContributionFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerContributionFilters: (registry: ContributionFilterRegistry) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use the registry to register your contribution filters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILogger {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          child: (name: string) => ILogger;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Create a child logger from this logger.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the child logger.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          debug: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the debug level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the debug level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          error: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the error level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the error level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method fatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fatal: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the fatal level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the fatal level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getLogLevel: () => Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Get the log level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            a Promise to the log level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifDebug: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the debug level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifEnabled: (logLevel: number) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the given log is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifError: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the error level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifFatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifFatal: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the fatal level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifInfo: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the info level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifTrace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifTrace: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the trace level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifWarn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ifWarn: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve if the warn level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          info: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the info level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the info level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDebug: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the debug level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnabled: (logLevel: number) => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the given log level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isError: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the error level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isFatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isFatal: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the fatal level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isInfo: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the info level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTrace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTrace: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the trace level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isWarn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isWarn: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Test whether the warn level is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          log: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (logLevel: number, loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (logLevel: number, message: any, ...params: any[]): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the given level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the given level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter logLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The loglevel to use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setLogLevel: (logLevel: number) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Set the log level.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter loglevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The loglevel to set. see Logger.LogLevel for possible options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method trace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          trace: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the trace level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the trace level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          warn: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (loggable: Loggable): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (message: any, ...params: any[]): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a loggable with the warn level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Log a message with the warn level if it is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The message format string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The format string variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonRpcConnectionEventEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonRpcConnectionEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onDidCloseConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly onDidCloseConnection: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDidOpenConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly onDidOpenConnection: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Measurement {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A Measurement counts the time elapsed between its creation when the Stopwatch is and when it is .

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property elapsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elapsed?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The elapsed time measured, if it has been and measured, or NaN if the platform disabled performance measurement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The measurement name. This may show up in the performance measurement framework appropriate to the application context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debug: (detail: string, ...optionalArgs: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time and log a debug message annotated with that timing information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a message detailing what activity was measured

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter optionalArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional message arguments as per the usual console API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error: (detail: string, ...optionalArgs: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time and log an error message annotated with that timing information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a message detailing what activity was measured

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter optionalArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional message arguments as per the usual console API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                info: (detail: string, ...optionalArgs: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time and log an info message annotated with that timing information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a message detailing what activity was measured

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter optionalArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional message arguments as per the usual console API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                log: (detail: string, ...optionalArgs: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time and log a message annotated with that timing information. The message is logged at the level determined by the MeasurementOptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a message detailing what activity was measured

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter optionalArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional message arguments as per the usual console API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time, in milliseconds, if not already done (only has effect on the first invocation). A NaN result indicates that the watch was stopped but failed to make a measurement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                warn: (detail: string, ...optionalArgs: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compute the elapsed time and log a warning message annotated with that timing information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a message detailing what activity was measured

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter optionalArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  optional message arguments as per the usual console API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MeasurementOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MeasurementOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Optional configuration of a Measurement specified at the time of its creation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                context?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A specific context of the application in which an activity was measured. Results in logs being emitted with a "[]" qualified at the head.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultLogLevel?: LogLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • An optional logging level at which to emit the log message. The default value is LogLevel.INFO.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property thresholdMillis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                thresholdMillis?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Some measurements are measured against a threshold (in millis) that they should not exceed. If omitted, the implied threshold is unlimited time (no threshold).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MenuAction {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A menu entry representing an action, e.g. "New File".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                alt?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • In addition to the mandatory command property, an alternative command can be defined. It will be shown and invoked when pressing Alt while opening a menu.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                commandId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The command to execute.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                icon?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Icon class(es). If not specified the icon class associated with the specified command (i.e. command.iconClass) will be used if it exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                label?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A specific label for this action. If not specified the command label or command id will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                order?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Menu entries are sorted in ascending order based on their order strings. If omitted the determined label will be used instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                when?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Optional expression which will be evaluated by the ContextKeyService to determine visibility of the action, e.g. resourceLangId == markdown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MenuContribution {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Representation of a menu contribution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note that there are also convenience classes which combine multiple contributions into one. For example to register a view together with a menu and keybinding you could use AbstractViewContribution instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ### Example usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  import { MenuContribution, MenuModelRegistry, MAIN_MENU_BAR } from '@theia/core';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  @injectable()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  export class NewMenuContribution implements MenuContribution {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  registerMenus(menus: MenuModelRegistry): void {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const menuPath = [...MAIN_MENU_BAR, '99_mymenu'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  menus.registerSubmenu(menuPath, 'My Menu');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  menus.registerMenuAction(menuPath, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  commandId: MyCommand.id,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label: 'My Action'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerMenus: (menus: MenuModelRegistry) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Registers menus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter menus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the menu model registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MenuNode {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Base interface of the nodes used in the menu tree structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • technical identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly label?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • the optional label for this specific node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly sortString: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Menu nodes are sorted in ascending order based on their sortString.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Message {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly actions?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Actions offered to the user in the context of the message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly options?: MessageOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Additional options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Message text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly type?: MessageType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type of the message, i.e. error, warning, info, etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MessageOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MessageOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Timeout in milliseconds. 0 and negative values are treated as no timeout.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Prioritizeable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Prioritizeable<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property priority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly priority: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly value: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Progress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Progress {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly cancel: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Cancel or complete the current progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Unique progress id.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly report: (update: ProgressUpdate) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Update the current progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                the data to update.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly result: Promise<string | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Result of the progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                a promise which resolves to either 'Cancel', an alternative action or undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProgressClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProgressClient {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method reportProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reportProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                progressId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                update: ProgressUpdate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cancellationToken: CancellationToken
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Update a previously created progress message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method showProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showProgress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                progressId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message: ProgressMessage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cancellationToken: CancellationToken
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<string | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Show a progress message with possible actions to user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ProgressMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ProgressMessage extends Message {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly options?: ProgressMessageOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly type?: MessageType.Progress;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressMessageOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressMessageOptions extends MessageOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cancelable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly cancelable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Default: false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly location?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Known values: notification | window | scm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ProgressUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ProgressUpdate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property message