@theia/core

  • Version 1.34.2
  • Published
  • 9.56 MB
  • 67 dependencies
  • EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 license

Install

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

Overview

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

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ACCOUNTS_MENU

const ACCOUNTS_MENU: MenuPath;

    variable ACCOUNTS_SUBMENU

    const ACCOUNTS_SUBMENU: string[];

      variable BackendStopwatch

      const BackendStopwatch: Symbol;

        variable BackendStopwatchOptions

        const BackendStopwatchOptions: Symbol;

          variable CommandContribution

          const CommandContribution: Symbol;

            variable CommandService

            const CommandService: Symbol;

              variable commandServicePath

              const commandServicePath: string;

                variable ConnectionHandler

                const ConnectionHandler: Symbol;

                  variable ContributionFilterRegistry

                  const ContributionFilterRegistry: Symbol;

                    variable ContributionProvider

                    const ContributionProvider: Symbol;

                      variable Filter

                      const Filter: Symbol;

                        variable FilterContribution

                        const FilterContribution: Symbol;

                          variable ILogger

                          const ILogger: Symbol;

                            variable isOSX

                            const isOSX: boolean;

                              variable isWindows

                              const isWindows: boolean;

                                variable logger

                                let logger: ILogger;

                                  variable LoggerFactory

                                  const LoggerFactory: Symbol;

                                    variable LoggerName

                                    const LoggerName: Symbol;
                                      const MAIN_MENU_BAR: MenuPath;

                                        variable MAX_SAFE_INTEGER

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

                                        variable MEMORY_TEXT

                                        const MEMORY_TEXT: string;
                                          const MenuCommandAdapter: Symbol;
                                            const MenuCommandAdapterRegistry: Symbol;
                                              const MenuCommandExecutor: Symbol;
                                                const MenuContribution: Symbol;

                                                  variable messageServicePath

                                                  const messageServicePath: string;

                                                    variable ProgressClient

                                                    const ProgressClient: Symbol;

                                                      variable QuickInputService

                                                      const QuickInputService: Symbol;

                                                        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 SETTINGS_MENU

                                                                  const SETTINGS_MENU: MenuPath;

                                                                    variable stopwatchPath

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

                                                                    variable UNTITLED_SCHEME

                                                                    const UNTITLED_SCHEME: string;

                                                                      Functions

                                                                      function bindContribution

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

                                                                        Parameter bindable

                                                                        a Container or the bind function directly.

                                                                        Parameter service

                                                                        an already bound service to refer the contributions to.

                                                                        Parameter contributions

                                                                        array of contribution identifiers to bind the service to.

                                                                      function bindContributionProvider

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

                                                                        function cancelled

                                                                        cancelled: () => Error;

                                                                          function checkCancelled

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

                                                                            function cmd

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

                                                                              function commonPrefixLength

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

                                                                                the length of the common prefix of the two strings.

                                                                              function compare

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

                                                                                function compareIgnoreCase

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

                                                                                  function compareSubstring

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

                                                                                    function compareSubstringIgnoreCase

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

                                                                                      function createUntitledURI

                                                                                      createUntitledURI: (extension?: string, parent?: URI) => URI;
                                                                                      • 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 isEmpty

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

                                                                                                    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 = Record<string | number | symbol, unknown>>(
                                                                                                              value: unknown
                                                                                                              ) => value is 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 isUpperAsciiLetter

                                                                                                                      isUpperAsciiLetter: (code: number) => boolean;

                                                                                                                        function notEmpty

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

                                                                                                                          function nullToUndefined

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

                                                                                                                          function setRootLogger

                                                                                                                          setRootLogger: (aLogger: ILogger) => void;

                                                                                                                            function split

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

                                                                                                                              function startsWithIgnoreCase

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

                                                                                                                                function unescapeInvisibleChars

                                                                                                                                unescapeInvisibleChars: (value: string) => string;

                                                                                                                                  function unreachable

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

                                                                                                                                  function unsetRootLogger

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

                                                                                                                                  Classes

                                                                                                                                  class 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 {}

                                                                                                                                                                                                                          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> implements ConnectionHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                    property factoryConstructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property targetFactory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                          method onConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                          onConnection: (connection: Channel) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                            class JsonRpcProxyFactory

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

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

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

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

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

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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              One the wire, it would look like this:

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter target

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            property connectionPromise

                                                                                                                                                                                                                                                                                                                                                                                                                                            protected connectionPromise: Promise<RpcProtocol>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property connectionPromiseResolve

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDidCloseConnectionEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly onDidCloseConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDidOpenConnectionEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly onDidOpenConnectionEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rpcConnectionFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected rpcConnectionFactory: RpcConnectionFactory;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                      target?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createProxy

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method deserializeError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method get

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            For example, if you have a Proxy object:

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter target

                                                                                                                                                                                                                                                                                                                                                                                                                                                            unused.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter p

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The property accessed on the Proxy object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter receiver

                                                                                                                                                                                                                                                                                                                                                                                                                                                            unused.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                            A callable that executes the JSON-RPC call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isNotification

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter p

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method listen

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onNotification

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onRequest

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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                            A promise of the method call completion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method serializeError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method waitForConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected waitForConnection: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Logger implements ILogger {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected created: Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property factory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly factory: LoggerFactory;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loggerWatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly loggerWatcher: LoggerWatcher;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly server: ILoggerServer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          child: (name: string) => ILogger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method debug

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method error

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fatal

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method format

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getLog

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getLogLevel: () => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method ifDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ifDebug: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ifEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method ifError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ifError: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ifFatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ifFatal: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ifInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ifInfo: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method ifTrace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ifTrace: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method ifWarn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ifWarn: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method info

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDebug: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isError: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFatal: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isInfo: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTrace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTrace: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isWarn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isWarn: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method log

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setLogLevel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method trace

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method warn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            warn: (arg: any | Loggable, ...params: any[]) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class 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 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 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: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => 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 SelectionService

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onSelectionChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly onSelectionChanged: Event<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onSelectionChangedEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly onSelectionChangedEmitter: Emitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selection: Object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Stopwatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract class Stopwatch {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected constructor(defaultLogOptions: LogOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultLogOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly defaultLogOptions: LogOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly logger: ILogger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method atLevel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createMeasurement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method log

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method logLevel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method mergeLogOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional configuration of the new measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a self-timing measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method startAsync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the to wrap around the function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter description

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter computation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a supplier of the asynchronous function to wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        optional addition configuration as for measure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the wrapped computation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SyncReferenceCollection

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property factory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method acquire

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getOrCreateValue

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UntitledResource implements Resource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly encoding: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly onDidChangeContents: Event<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeContentsEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly onDidChangeContentsEmitter: Emitter<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uri: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly version: ResourceVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fireDidChangeContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected fireDidChangeContents: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method readContents

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method saveContents

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class UntitledResourceResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class UntitledResourceResolver implements ResourceResolver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property resources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly resources: Map<string, UntitledResource>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createUntitledResource

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createUntitledURI

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              has: (uri: URI) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method resolve

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class URI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class URI {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(uri?: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allLocations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly allLocations: URI[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Return all uri from the current to the top most.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property authority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly authority: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • TODO move implementation to DefaultUriLabelProviderContribution.getName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          use LabelProvider.getName instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly fragment: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly parent: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly query: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly scheme: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method fromComponents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static fromComponents: (components: UriComponents) => URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method fromFilePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static fromFilePath: (path: string) => URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDistinctParents