@theia/core

  • Version 1.43.1
  • Published
  • 10.2 MB
  • 68 dependencies
  • EPL-2.0 OR GPL-2.0-only 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 EOL

                      const EOL: string;

                        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 MANAGE_MENU

                                          const MANAGE_MENU: 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 MenuCommandAdapter: Symbol;
                                                const MenuCommandAdapterRegistry: Symbol;
                                                  const MenuCommandExecutor: Symbol;
                                                    const MenuContribution: Symbol;

                                                      variable messageServicePath

                                                      const messageServicePath: string;

                                                        variable OSBackendProvider

                                                        const OSBackendProvider: Symbol;

                                                          variable OSBackendProviderPath

                                                          const OSBackendProviderPath: string;

                                                            variable ProgressClient

                                                            const ProgressClient: Symbol;

                                                              variable QuickInputService

                                                              const QuickInputService: Symbol;

                                                                variable quickInputServicePath

                                                                const quickInputServicePath: string;

                                                                  variable QuickPickService

                                                                  const QuickPickService: Symbol;

                                                                    variable quickPickServicePath

                                                                    const quickPickServicePath: string;

                                                                      variable ResourceProvider

                                                                      const ResourceProvider: Symbol;

                                                                        variable ResourceResolver

                                                                        const ResourceResolver: Symbol;

                                                                          variable rootLoggerName

                                                                          const rootLoggerName: string;

                                                                            variable stopwatchPath

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

                                                                            variable THEIA_VERSION

                                                                            const THEIA_VERSION: string;

                                                                              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 cloneAndChange

                                                                                      cloneAndChange: (obj: any, changer: (orig: any) => any) => any;

                                                                                        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;
                                                                                                  • Deprecated

                                                                                                    Since 1.27.0. Please use UntitledResourceResolver.createUntitledURI instead.

                                                                                                  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 filterItems

                                                                                                            filterItems: (
                                                                                                            items: QuickPickItemOrSeparator[],
                                                                                                            filter: string
                                                                                                            ) => QuickPickItemOrSeparator[];
                                                                                                            • Filter the list of quick pick items based on the provided filter. Items are filtered based on if: - their label satisfies the filter using fuzzy. - their description satisfies the filter using fuzzy. - their detail satisfies the filter using fuzzy. Filtered items are also updated to display proper highlights based on how they were filtered.

                                                                                                              Parameter items

                                                                                                              the list of quick pick items.

                                                                                                              Parameter filter

                                                                                                              the filter to search for.

                                                                                                              Returns

                                                                                                              the list of quick pick items that satisfy the filter.

                                                                                                            function findMatches

                                                                                                            findMatches: (
                                                                                                            word: string,
                                                                                                            pattern: string
                                                                                                            ) => Array<{ start: number; end: number }> | undefined;
                                                                                                            • Find match highlights when testing a word against a pattern.

                                                                                                              Parameter word

                                                                                                              the word to test.

                                                                                                              Parameter pattern

                                                                                                              the word to match against.

                                                                                                              Returns

                                                                                                              the list of highlights if present.

                                                                                                            function isArray

                                                                                                            isArray: <T>(
                                                                                                            value: unknown,
                                                                                                            every?: (value: unknown) => unknown,
                                                                                                            thisArg?: unknown
                                                                                                            ) => value is T[];
                                                                                                            • Parameter value

                                                                                                              value to check.

                                                                                                              Parameter every

                                                                                                              optional predicate ran on every element of the array.

                                                                                                              Parameter thisArg

                                                                                                              value to substitute this with when invoking in the predicate.

                                                                                                              Returns

                                                                                                              whether or not value is an array.

                                                                                                            function isBoolean

                                                                                                            isBoolean: (value: unknown) => value is boolean;

                                                                                                              function isCancelled

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

                                                                                                                function isDefined

                                                                                                                isDefined: <T>(arg: T | null | undefined) => arg is T;
                                                                                                                • Returns

                                                                                                                  whether the provided parameter is defined.

                                                                                                                function isEmpty

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

                                                                                                                function isEmptyObject

                                                                                                                isEmptyObject: (obj: unknown) => obj is object;
                                                                                                                • Returns

                                                                                                                  whether the provided parameter is an empty JavaScript Object or not.

                                                                                                                function isError

                                                                                                                isError: (value: unknown) => value is Error;

                                                                                                                  function isErrorLike

                                                                                                                  isErrorLike: (value: unknown) => value is Error;

                                                                                                                    function isFunction

                                                                                                                    isFunction: <T extends (...args: unknown[]) => unknown>(
                                                                                                                    value: unknown
                                                                                                                    ) => value is T;

                                                                                                                      function isLowerAsciiLetter

                                                                                                                      isLowerAsciiLetter: (code: number) => boolean;

                                                                                                                        function isNumber

                                                                                                                        isNumber: (value: unknown) => value is number;

                                                                                                                          function isObject

                                                                                                                          isObject: <T extends object>(value: unknown) => value is UnknownObject<T>;

                                                                                                                            function isString

                                                                                                                            isString: (value: unknown) => value is string;

                                                                                                                              function isStringArray

                                                                                                                              isStringArray: (value: unknown) => value is string[];

                                                                                                                                function isUndefined

                                                                                                                                isUndefined: (value: unknown) => value is undefined;

                                                                                                                                  function isUndefinedOrNull

                                                                                                                                  isUndefinedOrNull: (obj: unknown) => obj is null;
                                                                                                                                  • Returns

                                                                                                                                    whether the provided parameter is undefined or null.

                                                                                                                                  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 regExpFlags

                                                                                                                                      regExpFlags: (regexp: RegExp) => string;

                                                                                                                                        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 AbstractChannel

                                                                                                                                                abstract class AbstractChannel implements Channel {}
                                                                                                                                                • Reusable abstract Channel implementation that sets up the basic channel event listeners and offers a generic close method.

                                                                                                                                                constructor

                                                                                                                                                constructor();

                                                                                                                                                  property onClose

                                                                                                                                                  readonly onClose: Event<ChannelCloseEvent>;

                                                                                                                                                    property onCloseEmitter

                                                                                                                                                    onCloseEmitter: Emitter<ChannelCloseEvent>;

                                                                                                                                                      property onError

                                                                                                                                                      readonly onError: Event<unknown>;

                                                                                                                                                        property onErrorEmitter

                                                                                                                                                        onErrorEmitter: Emitter<unknown>;

                                                                                                                                                          property onMessage

                                                                                                                                                          readonly onMessage: Event<MessageProvider>;

                                                                                                                                                            property onMessageEmitter

                                                                                                                                                            onMessageEmitter: Emitter<MessageProvider>;

                                                                                                                                                              property toDispose

                                                                                                                                                              protected toDispose: DisposableCollection;

                                                                                                                                                                method close

                                                                                                                                                                close: () => void;

                                                                                                                                                                  method getWriteBuffer

                                                                                                                                                                  abstract getWriteBuffer: () => WriteBuffer;

                                                                                                                                                                    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, CommandMenuNode, Partial<AlternativeHandlerMenuNode> {}
                                                                                                                                                                                                        • 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

                                                                                                                                                                                                          protected readonly action: MenuAction;

                                                                                                                                                                                                            property altNode

                                                                                                                                                                                                            readonly altNode: ActionMenuNode;

                                                                                                                                                                                                              property command

                                                                                                                                                                                                              readonly command: string;

                                                                                                                                                                                                                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;

                                                                                                                                                                                                                          property when

                                                                                                                                                                                                                          readonly when: string;

                                                                                                                                                                                                                            class AsyncEmitter

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

                                                                                                                                                                                                                              property deliveryQueue

                                                                                                                                                                                                                              protected deliveryQueue: Promise<void>;

                                                                                                                                                                                                                                method deliver

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

                                                                                                                                                                                                                                  method fire

                                                                                                                                                                                                                                  fire: (
                                                                                                                                                                                                                                  event: WaitUntilData<T>,
                                                                                                                                                                                                                                  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 {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(parent?: CancellationToken);

                                                                                                                                                                                                                                          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 MutableCompoundMenuNode {}
                                                                                                                                                                                                                                                                              • Node representing a (sub)menu in the menu tree structure.

                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                              id: string,
                                                                                                                                                                                                                                                                              label?: string,
                                                                                                                                                                                                                                                                              options?: SubMenuOptions,
                                                                                                                                                                                                                                                                              parent?: MenuNodeMetadata &
                                                                                                                                                                                                                                                                              MenuNodeRenderingData &
                                                                                                                                                                                                                                                                              Partial<CompoundMenuNode> &
                                                                                                                                                                                                                                                                              Partial<CommandMenuNode> &
                                                                                                                                                                                                                                                                              Partial<AlternativeHandlerMenuNode> &
                                                                                                                                                                                                                                                                              CompoundMenuNode
                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                readonly children: readonly MenuNode[];

                                                                                                                                                                                                                                                                                  property icon

                                                                                                                                                                                                                                                                                  readonly icon: string;

                                                                                                                                                                                                                                                                                    property iconClass

                                                                                                                                                                                                                                                                                    iconClass?: string;

                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                      readonly id: string;

                                                                                                                                                                                                                                                                                        property isNavigationGroup

                                                                                                                                                                                                                                                                                        static isNavigationGroup: (node: MenuNode) => node is CompoundMenuNode;
                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                          1.28 use CompoundMenuNode.isNavigationGroup instead

                                                                                                                                                                                                                                                                                        property isSubmenu

                                                                                                                                                                                                                                                                                        readonly isSubmenu: boolean;

                                                                                                                                                                                                                                                                                          property label

                                                                                                                                                                                                                                                                                          label?: string;

                                                                                                                                                                                                                                                                                            property order

                                                                                                                                                                                                                                                                                            order?: string;

                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                              readonly parent?: MenuNodeMetadata &
                                                                                                                                                                                                                                                                                              MenuNodeRenderingData &
                                                                                                                                                                                                                                                                                              Partial<CompoundMenuNode> &
                                                                                                                                                                                                                                                                                              Partial<CommandMenuNode> &
                                                                                                                                                                                                                                                                                              Partial<AlternativeHandlerMenuNode> &
                                                                                                                                                                                                                                                                                              CompoundMenuNode;

                                                                                                                                                                                                                                                                                                property role

                                                                                                                                                                                                                                                                                                readonly role: CompoundMenuNodeRole;

                                                                                                                                                                                                                                                                                                  property sortString

                                                                                                                                                                                                                                                                                                  readonly sortString: string;

                                                                                                                                                                                                                                                                                                    property when

                                                                                                                                                                                                                                                                                                    readonly when: string;

                                                                                                                                                                                                                                                                                                      method addNode

                                                                                                                                                                                                                                                                                                      addNode: (node: MenuNode) => Disposable;

                                                                                                                                                                                                                                                                                                        method removeNode

                                                                                                                                                                                                                                                                                                        removeNode: (id: string) => void;

                                                                                                                                                                                                                                                                                                          method updateOptions

                                                                                                                                                                                                                                                                                                          updateOptions: (options?: SubMenuOptions) => void;

                                                                                                                                                                                                                                                                                                            class CompositeMenuNodeWrapper

                                                                                                                                                                                                                                                                                                            class CompositeMenuNodeWrapper implements MutableCompoundMenuNode {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                              wrapped: Readonly<MutableCompoundMenuNode>,
                                                                                                                                                                                                                                                                                                              parent: CompoundMenuNode,
                                                                                                                                                                                                                                                                                                              options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                readonly children: readonly MenuNode[];

                                                                                                                                                                                                                                                                                                                  property icon

                                                                                                                                                                                                                                                                                                                  readonly icon: string;

                                                                                                                                                                                                                                                                                                                    property iconClass

                                                                                                                                                                                                                                                                                                                    readonly iconClass: string;

                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                      readonly id: string;

                                                                                                                                                                                                                                                                                                                        property isSubmenu

                                                                                                                                                                                                                                                                                                                        readonly isSubmenu: boolean;

                                                                                                                                                                                                                                                                                                                          property label

                                                                                                                                                                                                                                                                                                                          readonly label: string;

                                                                                                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                                                                                                            protected readonly options?: SubMenuOptions;

                                                                                                                                                                                                                                                                                                                              property order

                                                                                                                                                                                                                                                                                                                              readonly order: string;

                                                                                                                                                                                                                                                                                                                                property parent

                                                                                                                                                                                                                                                                                                                                readonly parent: CompoundMenuNode;

                                                                                                                                                                                                                                                                                                                                  property role

                                                                                                                                                                                                                                                                                                                                  readonly role: CompoundMenuNodeRole;

                                                                                                                                                                                                                                                                                                                                    property sortString

                                                                                                                                                                                                                                                                                                                                    readonly sortString: string;

                                                                                                                                                                                                                                                                                                                                      property when

                                                                                                                                                                                                                                                                                                                                      readonly when: string;

                                                                                                                                                                                                                                                                                                                                        property wrapped

                                                                                                                                                                                                                                                                                                                                        protected readonly wrapped: Readonly<MutableCompoundMenuNode>;

                                                                                                                                                                                                                                                                                                                                          method addNode

                                                                                                                                                                                                                                                                                                                                          addNode: (node: MenuNode) => Disposable;

                                                                                                                                                                                                                                                                                                                                            method removeNode

                                                                                                                                                                                                                                                                                                                                            removeNode: (id: string) => void;

                                                                                                                                                                                                                                                                                                                                              method updateOptions

                                                                                                                                                                                                                                                                                                                                              updateOptions: (options: SubMenuOptions) => void;

                                                                                                                                                                                                                                                                                                                                                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, 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> extends RpcConnectionHandler<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                  since 1.39.0 use RpcConnectionHandler instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                class JsonRpcProxyFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                class JsonRpcProxyFactory<T extends object> extends RpcProxyFactory<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                  since 1.39.0 use RpcProxyFactory instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                class Logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                class Logger implements ILogger {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected init: () => 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 MenuCommandAdapterRegistryImpl implements MenuCommandAdapterRegistry {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly adapters: MenuCommandAdapter[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAdapterFor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...commandArgs: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MenuCommandAdapter | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerAdapter: (adapter: MenuCommandAdapter) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MenuCommandExecutorImpl implements MenuCommandExecutor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly adapterRegistry: MenuCommandAdapterRegistry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly commandRegistry: CommandRegistry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected delegate: <T extends keyof MenuCommandExecutor>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                commandArgs: unknown[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ReturnType<MenuCommandExecutor[T]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  executeCommand: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...commandArgs: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEnabled: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...commandArgs: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isToggled: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...commandArgs: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isVisible: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...commandArgs: unknown[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 independentSubmenus: Map<string, MutableCompoundMenuNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly root: CompositeMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected allChildrenCompound: (children: ReadonlyArray<MenuNode>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected findGroup: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menuPath: MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MutableCompoundMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Finds a submenu as a descendant of the root node. See .

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected findSubMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      current: MutableCompoundMenuNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menuId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MutableCompoundMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Finds or creates a submenu as an immediate child of current.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if a node with the given menuId exists but is not a MutableCompoundMenuNode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMenu: (menuPath?: MenuPath) => MutableCompoundMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMenuNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menuPath: MenuPath | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      group?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MutableCompoundMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPath: (node: MenuNode) => MenuPath | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the at which a given menu node can be accessed from this registry, if it can be determined. Returns undefined if the parent of any node in the chain is unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected isEmpty: (children: ReadonlyArray<MenuNode>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkSubmenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parentPath: MenuPath | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          childId: string | MenuPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: SubMenuOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          group?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onStart: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              registerIndependentSubmenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              label: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: SubMenuOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Disposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                menuNode: MenuNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                group?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeSingleRootNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fullMenuModel: MutableCompoundMenuNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                menuPath: MenuPath
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => CompoundMenuNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Checks the given menu model whether it will show a menu with a single submenu.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter fullMenuModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the menu model to analyze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter menuPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  the menu's path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if the menu will show a single submenu this returns a menu that will show the child elements of the submenu, otherwise the given fullMenuModel is return

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDidCancel?: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => 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 RpcConnectionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class RpcConnectionHandler<T extends object> implements ConnectionHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property factoryConstructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property targetFactory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onConnection: (connection: Channel) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class RpcProtocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class RpcProtocol {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Establish a RPC protocol on top of a given channel. By default the rpc protocol is bi-directional, meaning it is possible to send requests and notifications to the remote side (i.e. acts as client) as well as receiving requests and notifications from the remote side (i.e. acts as a server). Clients can get a promise for a remote request result that will be either resolved or rejected depending on the success of the request. Keeps track of outstanding requests and matches replies to the appropriate request Currently, there is no timeout handling for long running requests implemented. The bi-directional mode can be reconfigured using the RpcProtocolOptions to construct an RPC protocol instance that acts only as client or server instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        channel: Channel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requestHandler: RequestHandler,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: RpcProtocolOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property CANCELLATION_TOKEN_KEY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static readonly CANCELLATION_TOKEN_KEY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cancellationTokenSources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly cancellationTokenSources: Map<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CancellationTokenSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property channel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly channel: Channel;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property decoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly decoder: RpcMessageDecoder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property encoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly encoder: RpcMessageEncoder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly mode: 'default' | 'clientOnly' | 'serverOnly';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nextMessageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected nextMessageId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onNotification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onNotification: Event<{ method: string; args: any[] }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onNotificationEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly onNotificationEmitter: Emitter<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          args: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pendingRequests

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly pendingRequests: Map<number, Deferred<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property requestHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly requestHandler: RequestHandler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property toDispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected toDispose: DisposableCollection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleCancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected handleCancel: (id: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handleMessage: (message: RpcMessage) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleNotify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected handleNotify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method handleReply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected handleReply: (id: number, value: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleReplyErr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected handleReplyErr: (id: number, error: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handleRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected handleRequest: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method sendCancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sendCancel: (requestId: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method sendNotification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sendNotification: (method: string, args: any[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method sendRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sendRequest: <T>(method: string, args: any[]) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RpcProxyFactory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A RPC proxy exposes the programmatic interface of an object through Theia's RPC protocol. This allows remote programs to call methods of this objects by sending RPC requests. This takes place over a bi-directional stream, where both ends can expose an object and both can call methods on each other' 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 RPC interface. We would do:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let target = new Foo() let factory = new RpcProxyFactory('/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 RpcProxyFactory('/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:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      --> { "type":"1", "id": 1, "method": "bar", "args": [42]} <-- { "type":"3", "id": 1, "res": 43}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note that in the code of the caller, we didn't pass a target object to RpcProxyFactory, 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 RPC.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(target?: any, rpcProtocolFactory?: RpcProtocolFactory);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Build a new RpcProxyFactory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter target

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDidCloseConnectionEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly onDidCloseConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDidOpenConnectionEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly onDidOpenConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rpcDeferred

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected rpcDeferred: Deferred<RpcProtocol>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property rpcProtocolFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected rpcProtocolFactory: RpcProtocolFactory;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            target?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createProxy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If T implements RpcServer 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 RPC method call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Getting a property on the Proxy object returns a callable that, when called, executes a 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 RPC method call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, if you have a Proxy object:

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  accessing fooProxy.bar will return a callable that, when called, executes a 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 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: (channel: Channel) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Connect a Channel to the factory by creating an RpcProtocol on top of it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This protocol will be used to send/receive RPC requests and responses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onNotification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected onNotification: (method: string, ...args: any[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Process an incoming 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 RPC method call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onRequest is called when the 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 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(defaultLogOptions: LogOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly defaultLogOptions: LogOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly logger: ILogger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDidAddMeasurementResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly onDidAddMeasurementResult: Event<MeasurementResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDidAddMeasurementResultEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected onDidAddMeasurementResultEmitter: Emitter<MeasurementResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property storedMeasurements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly storedMeasurements: readonly MeasurementResult[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method atLevel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createMeasurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected createMeasurement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        measure: () => { startTime: number; duration: 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 TelemetryTrustedValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TelemetryTrustedValue<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(value: {});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly value: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource implements Resource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly encoding: string;