@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/workbench/contrib/debug/common/debug.js

@@ -12,17 +12,17 @@ const BREAKPOINTS_VIEW_ID = 'workbench.debug.breakPointsView';
 const DISASSEMBLY_VIEW_ID = 'workbench.debug.disassemblyView';
 const DEBUG_PANEL_ID = 'workbench.panel.repl';
 const REPL_VIEW_ID = 'workbench.panel.repl.view';
-const CONTEXT_DEBUG_TYPE = ( new RawContextKey('debugType', undefined, { type: 'string', description: ( localize(5901, "Debug type of the active debug session. For example 'python'.")) }));
+const CONTEXT_DEBUG_TYPE = ( new RawContextKey('debugType', undefined, { type: 'string', description: ( localize(5988, "Debug type of the active debug session. For example 'python'.")) }));
 const CONTEXT_DEBUG_CONFIGURATION_TYPE = ( new RawContextKey(
     'debugConfigurationType',
     undefined,
     { type: 'string', description: ( localize(
-        5902,
+        5989,
         "Debug type of the selected launch configuration. For example 'python'."
     )) }
 ));
 const CONTEXT_DEBUG_STATE = ( new RawContextKey('debugState', 'inactive', { type: 'string', description: ( localize(
-    5903,
+    5990,
     "State that the focused debug session is in. One of the following: 'inactive', 'initializing', 'stopped' or 'running'."
 )) }));
 const CONTEXT_DEBUG_UX_KEY = 'debugUx';
@@ -30,21 +30,21 @@ const CONTEXT_DEBUG_UX = ( new RawContextKey(
     CONTEXT_DEBUG_UX_KEY,
     'default',
     { type: 'string', description: ( localize(
-        5904,
+        5991,
         "Debug UX state. When there are no debug configurations it is 'simple', otherwise 'default'. Used to decide when to show welcome views in the debug viewlet."
     )) }
 ));
 const CONTEXT_HAS_DEBUGGED = ( new RawContextKey('hasDebugged', false, { type: 'boolean', description: ( localize(
-    5905,
+    5992,
     "True when a debug session has been started at least once, false otherwise."
 )) }));
-const CONTEXT_IN_DEBUG_MODE = ( new RawContextKey('inDebugMode', false, { type: 'boolean', description: ( localize(5906, "True when debugging, false otherwise.")) }));
-const CONTEXT_IN_DEBUG_REPL = ( new RawContextKey('inDebugRepl', false, { type: 'boolean', description: ( localize(5907, "True when focus is in the debug console, false otherwise.")) }));
+const CONTEXT_IN_DEBUG_MODE = ( new RawContextKey('inDebugMode', false, { type: 'boolean', description: ( localize(5993, "True when debugging, false otherwise.")) }));
+const CONTEXT_IN_DEBUG_REPL = ( new RawContextKey('inDebugRepl', false, { type: 'boolean', description: ( localize(5994, "True when focus is in the debug console, false otherwise.")) }));
 const CONTEXT_BREAKPOINT_WIDGET_VISIBLE = ( new RawContextKey(
     'breakpointWidgetVisible',
     false,
     { type: 'boolean', description: ( localize(
-        5908,
+        5995,
         "True when breakpoint editor zone widget is visible, false otherwise."
     )) }
 ));
@@ -52,40 +52,40 @@ const CONTEXT_IN_BREAKPOINT_WIDGET = ( new RawContextKey(
     'inBreakpointWidget',
     false,
     { type: 'boolean', description: ( localize(
-        5909,
+        5996,
         "True when focus is in the breakpoint editor zone widget, false otherwise."
     )) }
 ));
-const CONTEXT_BREAKPOINTS_FOCUSED = ( new RawContextKey('breakpointsFocused', true, { type: 'boolean', description: ( localize(5910, "True when the BREAKPOINTS view is focused, false otherwise.")) }));
+const CONTEXT_BREAKPOINTS_FOCUSED = ( new RawContextKey('breakpointsFocused', true, { type: 'boolean', description: ( localize(5997, "True when the BREAKPOINTS view is focused, false otherwise.")) }));
 const CONTEXT_WATCH_EXPRESSIONS_FOCUSED = ( new RawContextKey(
     'watchExpressionsFocused',
     true,
-    { type: 'boolean', description: ( localize(5911, "True when the WATCH view is focused, false otherwise.")) }
+    { type: 'boolean', description: ( localize(5998, "True when the WATCH view is focused, false otherwise.")) }
 ));
 const CONTEXT_WATCH_EXPRESSIONS_EXIST = ( new RawContextKey(
     'watchExpressionsExist',
     false,
-    { type: 'boolean', description: ( localize(5912, "True when at least one watch expression exists, false otherwise.")) }
+    { type: 'boolean', description: ( localize(5999, "True when at least one watch expression exists, false otherwise.")) }
 ));
-const CONTEXT_VARIABLES_FOCUSED = ( new RawContextKey('variablesFocused', true, { type: 'boolean', description: ( localize(5913, "True when the VARIABLES views is focused, false otherwise")) }));
+const CONTEXT_VARIABLES_FOCUSED = ( new RawContextKey('variablesFocused', true, { type: 'boolean', description: ( localize(6000, "True when the VARIABLES views is focused, false otherwise")) }));
 const CONTEXT_EXPRESSION_SELECTED = ( new RawContextKey(
     'expressionSelected',
     false,
     { type: 'boolean', description: ( localize(
-        5914,
+        6001,
         "True when an expression input box is open in either the WATCH or the VARIABLES view, false otherwise."
     )) }
 ));
 const CONTEXT_BREAKPOINT_INPUT_FOCUSED = ( new RawContextKey(
     'breakpointInputFocused',
     false,
-    { type: 'boolean', description: ( localize(5915, "True when the input box has focus in the BREAKPOINTS view.")) }
+    { type: 'boolean', description: ( localize(6002, "True when the input box has focus in the BREAKPOINTS view.")) }
 ));
 const CONTEXT_CALLSTACK_ITEM_TYPE = ( new RawContextKey(
     'callStackItemType',
     undefined,
     { type: 'string', description: ( localize(
-        5916,
+        6003,
         "Represents the item type of the focused element in the CALL STACK view. For example: 'session', 'thread', 'stackFrame'"
     )) }
 ));
@@ -93,7 +93,7 @@ const CONTEXT_CALLSTACK_SESSION_IS_ATTACH = ( new RawContextKey(
     'callStackSessionIsAttach',
     false,
     { type: 'boolean', description: ( localize(
-        5917,
+        6004,
         "True when the session in the CALL STACK view is attach, false otherwise. Used internally for inline menus in the CALL STACK view."
     )) }
 ));
@@ -101,7 +101,7 @@ const CONTEXT_CALLSTACK_ITEM_STOPPED = ( new RawContextKey(
     'callStackItemStopped',
     false,
     { type: 'boolean', description: ( localize(
-        5918,
+        6005,
         "True when the focused item in the CALL STACK is stopped. Used internaly for inline menus in the CALL STACK view."
     )) }
 ));
@@ -109,97 +109,97 @@ const CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD = ( new RawContextKey(
     'callStackSessionHasOneThread',
     false,
     { type: 'boolean', description: ( localize(
-        5919,
+        6006,
         "True when the focused session in the CALL STACK view has exactly one thread. Used internally for inline menus in the CALL STACK view."
     )) }
 ));
-const CONTEXT_CALLSTACK_FOCUSED = ( new RawContextKey('callStackFocused', true, { type: 'boolean', description: ( localize(5920, "True when the CALLSTACK view is focused, false otherwise.")) }));
+const CONTEXT_CALLSTACK_FOCUSED = ( new RawContextKey('callStackFocused', true, { type: 'boolean', description: ( localize(6007, "True when the CALLSTACK view is focused, false otherwise.")) }));
 const CONTEXT_WATCH_ITEM_TYPE = ( new RawContextKey('watchItemType', undefined, { type: 'string', description: ( localize(
-    5921,
+    6008,
     "Represents the item type of the focused element in the WATCH view. For example: 'expression', 'variable'"
 )) }));
 const CONTEXT_CAN_VIEW_MEMORY = ( new RawContextKey('canViewMemory', undefined, { type: 'boolean', description: ( localize(
-    5922,
+    6009,
     "Indicates whether the item in the view has an associated memory refrence."
 )) }));
 const CONTEXT_BREAKPOINT_ITEM_TYPE = ( new RawContextKey(
     'breakpointItemType',
     undefined,
     { type: 'string', description: ( localize(
-        5923,
+        6010,
         "Represents the item type of the focused element in the BREAKPOINTS view. For example: 'breakpoint', 'exceptionBreakppint', 'functionBreakpoint', 'dataBreakpoint'"
     )) }
 ));
 const CONTEXT_BREAKPOINT_ITEM_IS_DATA_BYTES = ( new RawContextKey(
     'breakpointItemBytes',
     undefined,
-    { type: 'boolean', description: ( localize(5924, "Whether the breakpoint item is a data breakpoint on a byte range.")) }
+    { type: 'boolean', description: ( localize(6011, "Whether the breakpoint item is a data breakpoint on a byte range.")) }
 ));
 const CONTEXT_BREAKPOINT_HAS_MODES = ( new RawContextKey(
     'breakpointHasModes',
     false,
-    { type: 'boolean', description: ( localize(5925, "Whether the breakpoint has multiple modes it can switch to.")) }
+    { type: 'boolean', description: ( localize(6012, "Whether the breakpoint has multiple modes it can switch to.")) }
 ));
 const CONTEXT_BREAKPOINT_SUPPORTS_CONDITION = ( new RawContextKey(
     'breakpointSupportsCondition',
     false,
-    { type: 'boolean', description: ( localize(5926, "True when the focused breakpoint supports conditions.")) }
+    { type: 'boolean', description: ( localize(6013, "True when the focused breakpoint supports conditions.")) }
 ));
 const CONTEXT_LOADED_SCRIPTS_SUPPORTED = ( new RawContextKey(
     'loadedScriptsSupported',
     false,
-    { type: 'boolean', description: ( localize(5927, "True when the focused sessions supports the LOADED SCRIPTS view")) }
+    { type: 'boolean', description: ( localize(6014, "True when the focused sessions supports the LOADED SCRIPTS view")) }
 ));
 const CONTEXT_LOADED_SCRIPTS_ITEM_TYPE = ( new RawContextKey(
     'loadedScriptsItemType',
     undefined,
     { type: 'string', description: ( localize(
-        5928,
+        6015,
         "Represents the item type of the focused element in the LOADED SCRIPTS view."
     )) }
 ));
 const CONTEXT_FOCUSED_SESSION_IS_ATTACH = ( new RawContextKey(
     'focusedSessionIsAttach',
     false,
-    { type: 'boolean', description: ( localize(5929, "True when the focused session is 'attach'.")) }
+    { type: 'boolean', description: ( localize(6016, "True when the focused session is 'attach'.")) }
 ));
 const CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG = ( new RawContextKey(
     'focusedSessionIsNoDebug',
     false,
-    { type: 'boolean', description: ( localize(5930, "True when the focused session is run without debugging.")) }
+    { type: 'boolean', description: ( localize(6017, "True when the focused session is run without debugging.")) }
 ));
-const CONTEXT_STEP_BACK_SUPPORTED = ( new RawContextKey('stepBackSupported', false, { type: 'boolean', description: ( localize(5931, "True when the focused session supports 'stepBack' requests.")) }));
+const CONTEXT_STEP_BACK_SUPPORTED = ( new RawContextKey('stepBackSupported', false, { type: 'boolean', description: ( localize(6018, "True when the focused session supports 'stepBack' requests.")) }));
 const CONTEXT_RESTART_FRAME_SUPPORTED = ( new RawContextKey(
     'restartFrameSupported',
     false,
-    { type: 'boolean', description: ( localize(5932, "True when the focused session supports 'restartFrame' requests.")) }
+    { type: 'boolean', description: ( localize(6019, "True when the focused session supports 'restartFrame' requests.")) }
 ));
 const CONTEXT_STACK_FRAME_SUPPORTS_RESTART = ( new RawContextKey(
     'stackFrameSupportsRestart',
     false,
-    { type: 'boolean', description: ( localize(5933, "True when the focused stack frame supports 'restartFrame'.")) }
+    { type: 'boolean', description: ( localize(6020, "True when the focused stack frame supports 'restartFrame'.")) }
 ));
 const CONTEXT_JUMP_TO_CURSOR_SUPPORTED = ( new RawContextKey(
     'jumpToCursorSupported',
     false,
-    { type: 'boolean', description: ( localize(5934, "True when the focused session supports 'jumpToCursor' request.")) }
+    { type: 'boolean', description: ( localize(6021, "True when the focused session supports 'jumpToCursor' request.")) }
 ));
 const CONTEXT_STEP_INTO_TARGETS_SUPPORTED = ( new RawContextKey(
     'stepIntoTargetsSupported',
     false,
-    { type: 'boolean', description: ( localize(5935, "True when the focused session supports 'stepIntoTargets' request.")) }
+    { type: 'boolean', description: ( localize(6022, "True when the focused session supports 'stepIntoTargets' request.")) }
 ));
-const CONTEXT_BREAKPOINTS_EXIST = ( new RawContextKey('breakpointsExist', false, { type: 'boolean', description: ( localize(5936, "True when at least one breakpoint exists.")) }));
+const CONTEXT_BREAKPOINTS_EXIST = ( new RawContextKey('breakpointsExist', false, { type: 'boolean', description: ( localize(6023, "True when at least one breakpoint exists.")) }));
 const CONTEXT_DEBUGGERS_AVAILABLE = ( new RawContextKey(
     'debuggersAvailable',
     false,
-    { type: 'boolean', description: ( localize(5937, "True when there is at least one debug extensions active.")) }
+    { type: 'boolean', description: ( localize(6024, "True when there is at least one debug extensions active.")) }
 ));
 const CONTEXT_DEBUG_EXTENSION_AVAILABLE = ( new RawContextKey(
     'debugExtensionAvailable',
     true,
     { type: 'boolean', description: ( localize(
-        5938,
+        6025,
         "True when there is at least one debug extension installed and enabled."
     )) }
 ));
@@ -207,33 +207,33 @@ const CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT = ( new RawContextKey(
     'debugProtocolVariableMenuContext',
     undefined,
     { type: 'string', description: ( localize(
-        5939,
+        6026,
         "Represents the context the debug adapter sets on the focused variable in the VARIABLES view."
     )) }
 ));
 const CONTEXT_SET_VARIABLE_SUPPORTED = ( new RawContextKey(
     'debugSetVariableSupported',
     false,
-    { type: 'boolean', description: ( localize(5940, "True when the focused session supports 'setVariable' request.")) }
+    { type: 'boolean', description: ( localize(6027, "True when the focused session supports 'setVariable' request.")) }
 ));
 const CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED = ( new RawContextKey(
     'debugSetDataBreakpointAddressSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5941,
+        6028,
         "True when the focused session supports 'getBreakpointInfo' request on an address."
     )) }
 ));
 const CONTEXT_SET_EXPRESSION_SUPPORTED = ( new RawContextKey(
     'debugSetExpressionSupported',
     false,
-    { type: 'boolean', description: ( localize(5942, "True when the focused session supports 'setExpression' request.")) }
+    { type: 'boolean', description: ( localize(6029, "True when the focused session supports 'setExpression' request.")) }
 ));
 const CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED = ( new RawContextKey(
     'breakWhenValueChangesSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5943,
+        6030,
         "True when the focused session supports to break when value changes."
     )) }
 ));
@@ -241,7 +241,7 @@ const CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED = ( new RawContextKey(
     'breakWhenValueIsAccessedSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5944,
+        6031,
         "True when the focused breakpoint supports to break when value is accessed."
     )) }
 ));
@@ -249,7 +249,7 @@ const CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED = ( new RawContextKey(
     'breakWhenValueIsReadSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5945,
+        6032,
         "True when the focused breakpoint supports to break when value is read."
     )) }
 ));
@@ -257,7 +257,7 @@ const CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED = ( new RawContextKey(
     'terminateDebuggeeSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5946,
+        6033,
         "True when the focused session supports the terminate debuggee capability."
     )) }
 ));
@@ -265,61 +265,61 @@ const CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED = ( new RawContextKey(
     'suspendDebuggeeSupported',
     false,
     { type: 'boolean', description: ( localize(
-        5947,
+        6034,
         "True when the focused session supports the suspend debuggee capability."
     )) }
 ));
 const CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT = ( new RawContextKey(
     'variableEvaluateNamePresent',
     false,
-    { type: 'boolean', description: ( localize(5948, "True when the focused variable has an 'evalauteName' field set.")) }
+    { type: 'boolean', description: ( localize(6035, "True when the focused variable has an 'evalauteName' field set.")) }
 ));
 const CONTEXT_VARIABLE_IS_READONLY = ( new RawContextKey(
     'variableIsReadonly',
     false,
-    { type: 'boolean', description: ( localize(5949, "True when the focused variable is read-only.")) }
+    { type: 'boolean', description: ( localize(6036, "True when the focused variable is read-only.")) }
 ));
-const CONTEXT_VARIABLE_VALUE = ( new RawContextKey('variableValue', false, { type: 'string', description: ( localize(5950, "Value of the variable, present for debug visualization clauses.")) }));
-const CONTEXT_VARIABLE_TYPE = ( new RawContextKey('variableType', false, { type: 'string', description: ( localize(5951, "Type of the variable, present for debug visualization clauses.")) }));
+const CONTEXT_VARIABLE_VALUE = ( new RawContextKey('variableValue', false, { type: 'string', description: ( localize(6037, "Value of the variable, present for debug visualization clauses.")) }));
+const CONTEXT_VARIABLE_TYPE = ( new RawContextKey('variableType', false, { type: 'string', description: ( localize(6038, "Type of the variable, present for debug visualization clauses.")) }));
 const CONTEXT_VARIABLE_INTERFACES = ( new RawContextKey('variableInterfaces', false, { type: 'array', description: ( localize(
-    5952,
+    6039,
     "Any interfaces or contracts that the variable satisfies, present for debug visualization clauses."
 )) }));
-const CONTEXT_VARIABLE_NAME = ( new RawContextKey('variableName', false, { type: 'string', description: ( localize(5953, "Name of the variable, present for debug visualization clauses.")) }));
+const CONTEXT_VARIABLE_NAME = ( new RawContextKey('variableName', false, { type: 'string', description: ( localize(6040, "Name of the variable, present for debug visualization clauses.")) }));
 const CONTEXT_VARIABLE_LANGUAGE = ( new RawContextKey('variableLanguage', false, { type: 'string', description: ( localize(
-    5954,
+    6041,
     "Language of the variable source, present for debug visualization clauses."
 )) }));
 const CONTEXT_VARIABLE_EXTENSIONID = ( new RawContextKey(
     'variableExtensionId',
     false,
     { type: 'string', description: ( localize(
-        5955,
+        6042,
         "Extension ID of the variable source, present for debug visualization clauses."
     )) }
 ));
 const CONTEXT_EXCEPTION_WIDGET_VISIBLE = ( new RawContextKey(
     'exceptionWidgetVisible',
     false,
-    { type: 'boolean', description: ( localize(5956, "True when the exception widget is visible.")) }
+    { type: 'boolean', description: ( localize(6043, "True when the exception widget is visible.")) }
 ));
-const CONTEXT_MULTI_SESSION_REPL = ( new RawContextKey('multiSessionRepl', false, { type: 'boolean', description: ( localize(5957, "True when there is more than 1 debug console.")) }));
-const CONTEXT_MULTI_SESSION_DEBUG = ( new RawContextKey('multiSessionDebug', false, { type: 'boolean', description: ( localize(5958, "True when there is more than 1 active debug session.")) }));
+const CONTEXT_MULTI_SESSION_REPL = ( new RawContextKey('multiSessionRepl', false, { type: 'boolean', description: ( localize(6044, "True when there is more than 1 debug console.")) }));
+const CONTEXT_MULTI_SESSION_DEBUG = ( new RawContextKey('multiSessionDebug', false, { type: 'boolean', description: ( localize(6045, "True when there is more than 1 active debug session.")) }));
 const CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED = ( new RawContextKey(
     'disassembleRequestSupported',
     false,
-    { type: 'boolean', description: ( localize(5959, "True when the focused sessions supports disassemble request.")) }
+    { type: 'boolean', description: ( localize(6046, "True when the focused sessions supports disassemble request.")) }
 ));
 const CONTEXT_DISASSEMBLY_VIEW_FOCUS = ( new RawContextKey(
     'disassemblyViewFocus',
     false,
-    { type: 'boolean', description: ( localize(5960, "True when the Disassembly View is focused.")) }
+    { type: 'boolean', description: ( localize(6047, "True when the Disassembly View is focused.")) }
 ));
 const CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST = ( new RawContextKey(
     'languageSupportsDisassembleRequest',
     false,
     { type: 'boolean', description: ( localize(
-        5961,
+        6048,
         "True when the language in the current editor supports disassemble request."
     )) }
 ));
@@ -327,12 +327,12 @@ const CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE = ( new RawC
     'focusedStackFrameHasInstructionReference',
     false,
     { type: 'boolean', description: ( localize(
-        5962,
+        6049,
         "True when the focused stack frame has instruction pointer reference."
     )) }
 ));
 const debuggerDisabledMessage = (debugType) => ( localize(
-    5963,
+    6050,
     "Configured debug type '{0}' is installed but not supported in this environment.",
     debugType
 ));
@@ -342,7 +342,7 @@ const DEBUG_SCHEME = 'debug';
 const INTERNAL_CONSOLE_OPTIONS_SCHEMA = {
     enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
     default: 'openOnFirstSessionStart',
-    description: ( localize(5964, "Controls when the internal Debug Console should open."))
+    description: ( localize(6051, "Controls when the internal Debug Console should open."))
 };
 var State;
 (function (State) {

package/vscode/src/vs/workbench/contrib/extensions/common/extensions.d.ts

@@ -0,0 +1,171 @@
+
+import './vscode-dts/vscode.proposed.d.ts'
+import './vscode-dts/vscode.d.ts'
+import { Event } from "../../../../base/common/event.js";
+import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IDeprecationInfo, InstallOptions } from "../../../../platform/extensionManagement/common/extensionManagement.js";
+import { EnablementState, IExtensionManagementServer, IResourceExtension } from "../../../services/extensionManagement/common/extensionManagement.js";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
+import { IExtensionManifest, ExtensionType } from "../../../../platform/extensions/common/extensions.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IView, IViewPaneContainer } from "../../../common/views.js";
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
+import { MenuId } from "../../../../platform/actions/common/actions.js";
+import { Severity } from "../../../../platform/notification/common/notification.js";
+import { IExtensionsWorkbenchService } from "./extensions.service.js";
+export declare const VIEWLET_ID = "workbench.view.extensions";
+export declare const EXTENSIONS_CATEGORY: import("../../../../nls.js").ILocalizedString;
+export interface IExtensionsViewPaneContainer extends IViewPaneContainer {
+    readonly searchValue: string | undefined;
+    search(text: string): void;
+    refresh(): Promise<void>;
+}
+export interface IWorkspaceRecommendedExtensionsView extends IView {
+    installWorkspaceRecommendations(): Promise<void>;
+}
+export declare enum ExtensionState {
+    Installing = 0,
+    Installed = 1,
+    Uninstalling = 2,
+    Uninstalled = 3
+}
+export declare enum ExtensionRuntimeActionType {
+    ReloadWindow = "reloadWindow",
+    RestartExtensions = "restartExtensions",
+    DownloadUpdate = "downloadUpdate",
+    ApplyUpdate = "applyUpdate",
+    QuitAndInstall = "quitAndInstall"
+}
+export type ExtensionRuntimeState = {
+    action: ExtensionRuntimeActionType;
+    reason: string;
+};
+export interface IExtension {
+    readonly type: ExtensionType;
+    readonly isBuiltin: boolean;
+    readonly isWorkspaceScoped: boolean;
+    readonly state: ExtensionState;
+    readonly name: string;
+    readonly displayName: string;
+    readonly identifier: IExtensionIdentifier;
+    readonly publisher: string;
+    readonly publisherDisplayName: string;
+    readonly publisherUrl?: URI;
+    readonly publisherDomain?: {
+        link: string;
+        verified: boolean;
+    };
+    readonly publisherSponsorLink?: URI;
+    readonly pinned: boolean;
+    readonly version: string;
+    readonly private: boolean;
+    readonly latestVersion: string;
+    readonly preRelease: boolean;
+    readonly isPreReleaseVersion: boolean;
+    readonly hasPreReleaseVersion: boolean;
+    readonly hasReleaseVersion: boolean;
+    readonly description: string;
+    readonly url?: string;
+    readonly repository?: string;
+    readonly supportUrl?: string;
+    readonly iconUrl: string;
+    readonly iconUrlFallback: string;
+    readonly licenseUrl?: string;
+    readonly installCount?: number;
+    readonly rating?: number;
+    readonly ratingCount?: number;
+    readonly ratingUrl?: string;
+    readonly outdated: boolean;
+    readonly outdatedTargetPlatform: boolean;
+    readonly runtimeState: ExtensionRuntimeState | undefined;
+    readonly enablementState: EnablementState;
+    readonly tags: readonly string[];
+    readonly categories: readonly string[];
+    readonly dependencies: string[];
+    readonly extensionPack: string[];
+    readonly telemetryData: any;
+    readonly preview: boolean;
+    getManifest(token: CancellationToken): Promise<IExtensionManifest | null>;
+    hasReadme(): boolean;
+    getReadme(token: CancellationToken): Promise<string>;
+    hasChangelog(): boolean;
+    getChangelog(token: CancellationToken): Promise<string>;
+    readonly server?: IExtensionManagementServer;
+    readonly local?: ILocalExtension;
+    gallery?: IGalleryExtension;
+    readonly resourceExtension?: IResourceExtension;
+    readonly isMalicious: boolean | undefined;
+    readonly maliciousInfoLink: string | undefined;
+    readonly deprecationInfo?: IDeprecationInfo;
+}
+export interface InstallExtensionOptions extends InstallOptions {
+    version?: string;
+    justification?: string | {
+        reason: string;
+        action: string;
+    };
+    enable?: boolean;
+    installEverywhere?: boolean;
+}
+export interface IExtensionsNotification {
+    readonly message: string;
+    readonly severity: Severity;
+    readonly extensions: IExtension[];
+    dismiss(): void;
+}
+export declare enum ExtensionEditorTab {
+    Readme = "readme",
+    Features = "features",
+    Changelog = "changelog",
+    Dependencies = "dependencies",
+    ExtensionPack = "extensionPack"
+}
+export declare const ConfigurationKey = "extensions";
+export declare const AutoUpdateConfigurationKey = "extensions.autoUpdate";
+export declare const AutoCheckUpdatesConfigurationKey = "extensions.autoCheckUpdates";
+export declare const CloseExtensionDetailsOnViewChangeKey = "extensions.closeExtensionDetailsOnViewChange";
+export declare const AutoRestartConfigurationKey = "extensions.autoRestart";
+export type AutoUpdateConfigurationValue = boolean | "onlyEnabledExtensions" | "onlySelectedExtensions";
+export interface IExtensionsConfiguration {
+    autoUpdate: boolean;
+    autoCheckUpdates: boolean;
+    ignoreRecommendations: boolean;
+    closeExtensionDetailsOnViewChange: boolean;
+}
+export interface IExtensionContainer extends IDisposable {
+    extension: IExtension | null;
+    updateWhenCounterExtensionChanges?: boolean;
+    update(): void;
+}
+export interface IExtensionsViewState {
+    onFocus: Event<IExtension>;
+    onBlur: Event<IExtension>;
+    filters: {
+        featureId?: string;
+    };
+}
+export declare class ExtensionContainers extends Disposable {
+    private readonly containers;
+    constructor(containers: IExtensionContainer[], extensionsWorkbenchService: IExtensionsWorkbenchService);
+    set extension(extension: IExtension);
+    private update;
+}
+export declare const WORKSPACE_RECOMMENDATIONS_VIEW_ID = "workbench.views.extensions.workspaceRecommendations";
+export declare const OUTDATED_EXTENSIONS_VIEW_ID = "workbench.views.extensions.searchOutdated";
+export declare const TOGGLE_IGNORE_EXTENSION_ACTION_ID = "workbench.extensions.action.toggleIgnoreExtension";
+export declare const SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID = "workbench.extensions.action.installVSIX";
+export declare const INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID = "workbench.extensions.command.installFromVSIX";
+export declare const LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID = "workbench.extensions.action.listWorkspaceUnsupportedExtensions";
+export declare const HasOutdatedExtensionsContext: RawContextKey<boolean>;
+export declare const CONTEXT_HAS_GALLERY: RawContextKey<boolean>;
+export declare const ExtensionResultsListFocused: RawContextKey<boolean>;
+export declare const THEME_ACTIONS_GROUP = "_theme_";
+export declare const INSTALL_ACTIONS_GROUP = "0_install";
+export declare const UPDATE_ACTIONS_GROUP = "0_update";
+export declare const extensionsSearchActionsMenu: MenuId;
+export interface IExtensionArg {
+    id: string;
+    version: string;
+    location: URI | undefined;
+    galleryLink: string | undefined;
+}

package/vscode/src/vs/workbench/contrib/extensions/common/extensions.js

@@ -0,0 +1,85 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { localize2 } from '../../../../nls.js';
+import { IExtensionsWorkbenchService } from './extensions.service.js';
+
+const VIEWLET_ID = 'workbench.view.extensions';
+const EXTENSIONS_CATEGORY = ( localize2(6786, "Extensions"));
+var ExtensionState;
+(function (ExtensionState) {
+    ExtensionState[ExtensionState["Installing"] = 0] = "Installing";
+    ExtensionState[ExtensionState["Installed"] = 1] = "Installed";
+    ExtensionState[ExtensionState["Uninstalling"] = 2] = "Uninstalling";
+    ExtensionState[ExtensionState["Uninstalled"] = 3] = "Uninstalled";
+})(ExtensionState || (ExtensionState = {}));
+var ExtensionRuntimeActionType;
+(function (ExtensionRuntimeActionType) {
+    ExtensionRuntimeActionType["ReloadWindow"] = "reloadWindow";
+    ExtensionRuntimeActionType["RestartExtensions"] = "restartExtensions";
+    ExtensionRuntimeActionType["DownloadUpdate"] = "downloadUpdate";
+    ExtensionRuntimeActionType["ApplyUpdate"] = "applyUpdate";
+    ExtensionRuntimeActionType["QuitAndInstall"] = "quitAndInstall";
+})(ExtensionRuntimeActionType || (ExtensionRuntimeActionType = {}));
+var ExtensionEditorTab;
+(function (ExtensionEditorTab) {
+    ExtensionEditorTab["Readme"] = "readme";
+    ExtensionEditorTab["Features"] = "features";
+    ExtensionEditorTab["Changelog"] = "changelog";
+    ExtensionEditorTab["Dependencies"] = "dependencies";
+    ExtensionEditorTab["ExtensionPack"] = "extensionPack";
+})(ExtensionEditorTab || (ExtensionEditorTab = {}));
+const AutoUpdateConfigurationKey = 'extensions.autoUpdate';
+const AutoCheckUpdatesConfigurationKey = 'extensions.autoCheckUpdates';
+const CloseExtensionDetailsOnViewChangeKey = 'extensions.closeExtensionDetailsOnViewChange';
+const AutoRestartConfigurationKey = 'extensions.autoRestart';
+let ExtensionContainers = class ExtensionContainers extends Disposable {
+    constructor(containers, extensionsWorkbenchService) {
+        super();
+        this.containers = containers;
+        this._register(extensionsWorkbenchService.onChange(this.update, this));
+    }
+    set extension(extension) {
+        this.containers.forEach(c => c.extension = extension);
+    }
+    update(extension) {
+        for (const container of this.containers) {
+            if (extension && container.extension) {
+                if (areSameExtensions(container.extension.identifier, extension.identifier)) {
+                    if (container.extension.server && extension.server && container.extension.server !== extension.server) {
+                        if (container.updateWhenCounterExtensionChanges) {
+                            container.update();
+                        }
+                    }
+                    else {
+                        container.extension = extension;
+                    }
+                }
+            }
+            else {
+                container.update();
+            }
+        }
+    }
+};
+ExtensionContainers = ( __decorate([
+    ( __param(1, IExtensionsWorkbenchService))
+], ExtensionContainers));
+const WORKSPACE_RECOMMENDATIONS_VIEW_ID = 'workbench.views.extensions.workspaceRecommendations';
+const OUTDATED_EXTENSIONS_VIEW_ID = 'workbench.views.extensions.searchOutdated';
+const TOGGLE_IGNORE_EXTENSION_ACTION_ID = 'workbench.extensions.action.toggleIgnoreExtension';
+const SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID = 'workbench.extensions.action.installVSIX';
+const INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID = 'workbench.extensions.command.installFromVSIX';
+const LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID = 'workbench.extensions.action.listWorkspaceUnsupportedExtensions';
+const HasOutdatedExtensionsContext = ( new RawContextKey('hasOutdatedExtensions', false));
+const CONTEXT_HAS_GALLERY = ( new RawContextKey('hasGallery', false));
+const ExtensionResultsListFocused = ( new RawContextKey('extensionResultListFocused ', true));
+const THEME_ACTIONS_GROUP = '_theme_';
+const INSTALL_ACTIONS_GROUP = '0_install';
+const UPDATE_ACTIONS_GROUP = '0_update';
+const extensionsSearchActionsMenu = ( new MenuId('extensionsSearchActionsMenu'));
+
+export { AutoCheckUpdatesConfigurationKey, AutoRestartConfigurationKey, AutoUpdateConfigurationKey, CONTEXT_HAS_GALLERY, CloseExtensionDetailsOnViewChangeKey, EXTENSIONS_CATEGORY, ExtensionContainers, ExtensionEditorTab, ExtensionResultsListFocused, ExtensionRuntimeActionType, ExtensionState, HasOutdatedExtensionsContext, INSTALL_ACTIONS_GROUP, INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID, OUTDATED_EXTENSIONS_VIEW_ID, SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID, THEME_ACTIONS_GROUP, TOGGLE_IGNORE_EXTENSION_ACTION_ID, UPDATE_ACTIONS_GROUP, VIEWLET_ID, WORKSPACE_RECOMMENDATIONS_VIEW_ID, extensionsSearchActionsMenu };