@codingame/monaco-vscode-api 18.4.0 → 19.0.1

package/vscode/src/vs/workbench/services/authentication/common/authenticationQuery.d.ts

@@ -0,0 +1,132 @@
+import { AuthenticationSessionAccount } from "./authentication.js";
+export interface IAuthenticationUsageStats {
+    readonly totalSessions: number;
+    readonly totalAccounts: number;
+    readonly recentActivity: {
+        readonly accountName: string;
+        readonly lastUsed: number;
+        readonly usageCount: number;
+    }[];
+}
+export interface IActiveEntities {
+    readonly extensions: string[];
+    readonly mcpServers: string[];
+}
+export interface IBaseQuery {
+    readonly providerId: string;
+}
+export interface IAccountQuery extends IBaseQuery {
+    readonly accountName: string;
+    extension(extensionId: string): IAccountExtensionQuery;
+    mcpServer(mcpServerId: string): IAccountMcpServerQuery;
+    extensions(): IAccountExtensionsQuery;
+    mcpServers(): IAccountMcpServersQuery;
+    entities(): IAccountEntitiesQuery;
+    remove(): void;
+}
+export interface IAccountExtensionQuery extends IBaseQuery {
+    readonly accountName: string;
+    readonly extensionId: string;
+    isAccessAllowed(): boolean | undefined;
+    setAccessAllowed(allowed: boolean, extensionName?: string): void;
+    addUsage(scopes: readonly string[], extensionName: string): void;
+    getUsage(): {
+        readonly extensionId: string;
+        readonly extensionName: string;
+        readonly scopes: readonly string[];
+        readonly lastUsed: number;
+    }[];
+    removeUsage(): void;
+    setAsPreferred(): void;
+    isPreferred(): boolean;
+    isTrusted(): boolean;
+}
+export interface IAccountMcpServerQuery extends IBaseQuery {
+    readonly accountName: string;
+    readonly mcpServerId: string;
+    isAccessAllowed(): boolean | undefined;
+    setAccessAllowed(allowed: boolean, mcpServerName?: string): void;
+    addUsage(scopes: readonly string[], mcpServerName: string): void;
+    getUsage(): {
+        readonly mcpServerId: string;
+        readonly mcpServerName: string;
+        readonly scopes: readonly string[];
+        readonly lastUsed: number;
+    }[];
+    removeUsage(): void;
+    setAsPreferred(): void;
+    isPreferred(): boolean;
+    isTrusted(): boolean;
+}
+export interface IAccountExtensionsQuery extends IBaseQuery {
+    readonly accountName: string;
+    getAllowedExtensions(): {
+        id: string;
+        name: string;
+        allowed?: boolean;
+        lastUsed?: number;
+        trusted?: boolean;
+    }[];
+    allowAccess(extensionIds: string[]): void;
+    removeAccess(extensionIds: string[]): void;
+    forEach(callback: (extensionQuery: IAccountExtensionQuery) => void): void;
+}
+export interface IAccountMcpServersQuery extends IBaseQuery {
+    readonly accountName: string;
+    getAllowedMcpServers(): {
+        id: string;
+        name: string;
+        allowed?: boolean;
+        lastUsed?: number;
+        trusted?: boolean;
+    }[];
+    allowAccess(mcpServerIds: string[]): void;
+    removeAccess(mcpServerIds: string[]): void;
+    forEach(callback: (mcpServerQuery: IAccountMcpServerQuery) => void): void;
+}
+export interface IAccountEntitiesQuery extends IBaseQuery {
+    readonly accountName: string;
+    hasAnyUsage(): boolean;
+    getEntityCount(): {
+        extensions: number;
+        mcpServers: number;
+        total: number;
+    };
+    removeAllAccess(): void;
+    forEach(callback: (entityId: string, entityType: "extension" | "mcpServer") => void): void;
+}
+export interface IProviderExtensionQuery extends IBaseQuery {
+    readonly extensionId: string;
+    getPreferredAccount(): string | undefined;
+    setPreferredAccount(account: AuthenticationSessionAccount): void;
+    removeAccountPreference(): void;
+}
+export interface IProviderMcpServerQuery extends IBaseQuery {
+    readonly mcpServerId: string;
+    getLastUsedAccount(): Promise<string | undefined>;
+    getPreferredAccount(): string | undefined;
+    setPreferredAccount(account: AuthenticationSessionAccount): void;
+    removeAccountPreference(): void;
+    getUsedAccounts(): Promise<string[]>;
+}
+export interface IProviderQuery extends IBaseQuery {
+    account(accountName: string): IAccountQuery;
+    extension(extensionId: string): IProviderExtensionQuery;
+    mcpServer(mcpServerId: string): IProviderMcpServerQuery;
+    getActiveEntities(): Promise<IActiveEntities>;
+    getAccountNames(): Promise<string[]>;
+    getUsageStats(): Promise<IAuthenticationUsageStats>;
+    forEachAccount(callback: (accountQuery: IAccountQuery) => void): Promise<void>;
+}
+export interface IExtensionQuery {
+    readonly extensionId: string;
+    getProvidersWithAccess(includeInternal?: boolean): Promise<string[]>;
+    getAllAccountPreferences(includeInternal?: boolean): Map<string, string>;
+    provider(providerId: string): IProviderExtensionQuery;
+}
+export interface IMcpServerQuery {
+    readonly mcpServerId: string;
+    getProvidersWithAccess(includeInternal?: boolean): Promise<string[]>;
+    getAllAccountPreferences(includeInternal?: boolean): Map<string, string>;
+    provider(providerId: string): IProviderMcpServerQuery;
+}

package/vscode/src/vs/workbench/services/authentication/common/authenticationQuery.service.d.ts

@@ -0,0 +1,20 @@
+import { Event } from "../../../../base/common/event.js";
+import { IProviderQuery, IExtensionQuery, IMcpServerQuery } from "./authenticationQuery.js";
+export declare const IAuthenticationQueryService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationQueryService>;
+export interface IAuthenticationQueryService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangePreferences: Event<{
+        readonly providerId: string;
+        readonly entityType: "extension" | "mcpServer";
+        readonly entityIds: string[];
+    }>;
+    readonly onDidChangeAccess: Event<{
+        readonly providerId: string;
+        readonly accountName: string;
+    }>;
+    provider(providerId: string): IProviderQuery;
+    extension(extensionId: string): IExtensionQuery;
+    mcpServer(mcpServerId: string): IMcpServerQuery;
+    getProviderIds(): string[];
+    clearAllData(confirmation: "CLEAR_ALL_AUTH_DATA", includeInternal?: boolean): Promise<void>;
+}

package/vscode/src/vs/workbench/services/authentication/common/authenticationQuery.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IAuthenticationQueryService = ( createDecorator('IAuthenticationQueryService'));
+
+export { IAuthenticationQueryService };

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolver.service.d.ts

@@ -9,7 +9,7 @@ export interface IConfigurationResolverService {
     readonly resolvableVariables: ReadonlySet<string>;
     resolveWithEnvironment(environment: IProcessEnvironment, folder: IWorkspaceFolderData | undefined, value: string): Promise<string>;
     resolveAsync<T>(folder: IWorkspaceFolderData | undefined, config: T): Promise<T extends ConfigurationResolverExpression<infer R> ? R : T>;
-    resolveWithInteractionReplace(folder: IWorkspaceFolderData | undefined, config: any, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<any>;
-    resolveWithInteraction(folder: IWorkspaceFolderData | undefined, config: any, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<Map<string, string> | undefined>;
+    resolveWithInteractionReplace(folder: IWorkspaceFolderData | undefined, config: unknown, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<any>;
+    resolveWithInteraction(folder: IWorkspaceFolderData | undefined, config: unknown, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<Map<string, string> | undefined>;
     contributeVariable(variable: string, resolution: () => Promise<string | undefined>): void;
 }

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -81,7 +81,7 @@ class AbstractVariableResolverService {
                 return normalizeDriveLetter(filePath);
             }
             throw ( new VariableError(variableKind, ( localize(
-                12418,
+                12693,
                 "Variable {0} can not be resolved. Please open an editor.",
                 replacement.id
             ))));
@@ -95,7 +95,7 @@ class AbstractVariableResolverService {
                 }
             }
             throw ( new VariableError(variableKind, ( localize(
-                12419,
+                12694,
                 "Variable {0}: can not find workspace folder of '{1}'.",
                 replacement.id,
                 basename(filePath)
@@ -108,7 +108,7 @@ class AbstractVariableResolverService {
                     return folder;
                 }
                 throw ( new VariableError(variableKind, ( localize(
-                    12420,
+                    12695,
                     "Variable {0} can not be resolved. No such folder '{1}'.",
                     variableKind,
                     argument
@@ -119,13 +119,13 @@ class AbstractVariableResolverService {
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
                 throw ( new VariableError(variableKind, ( localize(
-                    12421,
+                    12696,
                     "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
                     variableKind
                 ))));
             }
             throw ( new VariableError(variableKind, ( localize(
-                12422,
+                12697,
                 "Variable {0} can not be resolved. Please open a folder.",
                 variableKind
             ))));
@@ -142,7 +142,7 @@ class AbstractVariableResolverService {
                     return '';
                 }
                 throw ( new VariableError(VariableKind.Env, ( localize(
-                    12423,
+                    12698,
                     "Variable {0} can not be resolved because no environment variable name is given.",
                     replacement.id
                 ))));
@@ -151,7 +151,7 @@ class AbstractVariableResolverService {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            12424,
+                            12699,
                             "Variable {0} can not be resolved because setting '{1}' not found.",
                             replacement.id,
                             argument
@@ -159,7 +159,7 @@ class AbstractVariableResolverService {
                     }
                     if (isObject(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            12425,
+                            12700,
                             "Variable {0} can not be resolved because '{1}' is a structured value.",
                             replacement.id,
                             argument
@@ -168,7 +168,7 @@ class AbstractVariableResolverService {
                     return config;
                 }
                 throw ( new VariableError(VariableKind.Config, ( localize(
-                    12426,
+                    12701,
                     "Variable {0} can not be resolved because no settings name is given.",
                     replacement.id
                 ))));
@@ -181,7 +181,7 @@ class AbstractVariableResolverService {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
                         throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                            12427,
+                            12702,
                             "Variable {0} can not be resolved because the extension {1} is not installed.",
                             replacement.id,
                             argument
@@ -190,7 +190,7 @@ class AbstractVariableResolverService {
                     return this.fsPath(ext.extensionLocation);
                 }
                 throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                    12428,
+                    12703,
                     "Variable {0} can not be resolved because no extension name is given.",
                     replacement.id
                 ))));
@@ -218,7 +218,7 @@ class AbstractVariableResolverService {
                             return environment.userHome;
                         }
                         throw ( new VariableError(VariableKind.UserHome, ( localize(
-                            12429,
+                            12704,
                             "Variable {0} can not be resolved. UserHome path is not defined",
                             replacement.id
                         ))));
@@ -228,7 +228,7 @@ class AbstractVariableResolverService {
                             return lineNumber;
                         }
                         throw ( new VariableError(VariableKind.LineNumber, ( localize(
-                            12430,
+                            12705,
                             "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
                             replacement.id
                         ))));
@@ -239,7 +239,7 @@ class AbstractVariableResolverService {
                             return columnNumber;
                         }
                         throw ( new Error(( localize(
-                            12431,
+                            12706,
                             "Variable {0} can not be resolved. Make sure to have a column selected in the active editor.",
                             replacement.id
                         ))));
@@ -250,7 +250,7 @@ class AbstractVariableResolverService {
                             return selectedText;
                         }
                         throw ( new VariableError(VariableKind.SelectedText, ( localize(
-                            12432,
+                            12707,
                             "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
                             replacement.id
                         ))));
@@ -322,7 +322,7 @@ class AbstractVariableResolverService {
                 return v;
             }
             throw ( new VariableError(variableKind, ( localize(
-                12433,
+                12708,
                 "Variable {0} can not be resolved because the command has no value.",
                 match
             ))));

package/vscode/src/vs/workbench/services/coreExperimentation/common/coreExperimentationService.service.d.ts

@@ -0,0 +1,6 @@
+import { IExperiment } from "@codingame/monaco-vscode-516ccb00-d5b9-5317-baf0-fcc96e99669a-common/vscode/vs/workbench/services/coreExperimentation/common/coreExperimentationService";
+export declare const ICoreExperimentationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ICoreExperimentationService>;
+export interface ICoreExperimentationService {
+    readonly _serviceBrand: undefined;
+    getExperiment(): IExperiment | undefined;
+}

package/vscode/src/vs/workbench/services/coreExperimentation/common/coreExperimentationService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ICoreExperimentationService = ( createDecorator('coreExperimentationService'));
+
+export { ICoreExperimentationService };

package/vscode/src/vs/workbench/services/editor/common/editorGroupsService.d.ts

@@ -8,7 +8,7 @@ import { DisposableStore, IDisposable } from "../../../../base/common/lifecycle.
 import { ContextKeyValue, RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IGroupModelChangeEvent } from "@codingame/monaco-vscode-c3c61c00-c254-5856-9dc9-d7929c1f9062-common/vscode/vs/workbench/common/editor/editorGroupModel";
+import { IGroupModelChangeEvent } from "@codingame/monaco-vscode-ca445022-b812-53ca-a041-e46c7e0b13de-common/vscode/vs/workbench/common/editor/editorGroupModel";
 import { IMenuChangeEvent, MenuId } from "../../../../platform/actions/common/actions.js";
 import { DeepPartial } from "../../../../base/common/types.js";
 export declare enum GroupDirection {

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -16,7 +16,7 @@ const editorAssociationsConfigurationNode = {
         'workbench.editorAssociations': {
             type: 'object',
             markdownDescription: ( localize(
-                12486,
+                12761,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {

package/vscode/src/vs/workbench/services/editor/common/editorService.d.ts

@@ -1,7 +1,7 @@
 import { GroupIdentifier, ISaveOptions, IRevertOptions, IUntypedEditorInput } from "../../../common/editor.js";
 import { EditorInput } from "../../../common/editor/editorInput.js";
 import { IEditorGroup } from "./editorGroupsService.js";
-import { IGroupModelChangeEvent } from "@codingame/monaco-vscode-c3c61c00-c254-5856-9dc9-d7929c1f9062-common/vscode/vs/workbench/common/editor/editorGroupModel";
+import { IGroupModelChangeEvent } from "@codingame/monaco-vscode-ca445022-b812-53ca-a041-e46c7e0b13de-common/vscode/vs/workbench/common/editor/editorGroupModel";
 export declare const ACTIVE_GROUP = -1;
 export type ACTIVE_GROUP_TYPE = typeof ACTIVE_GROUP;
 export declare const SIDE_GROUP = -2;

package/vscode/src/vs/workbench/services/editor/common/editorService.service.d.ts

@@ -41,9 +41,9 @@ export interface IEditorService {
     closeEditors(editors: readonly IEditorIdentifier[], options?: ICloseEditorOptions): Promise<void>;
     findEditors(resource: URI, options?: IFindEditorOptions): readonly IEditorIdentifier[];
     findEditors(editor: IResourceEditorInputIdentifier, options?: IFindEditorOptions): readonly IEditorIdentifier[];
-    save(editors: IEditorIdentifier | IEditorIdentifier[], options?: ISaveEditorsOptions): Promise<ISaveEditorsResult>;
+    save(editors: IEditorIdentifier | readonly IEditorIdentifier[], options?: ISaveEditorsOptions): Promise<ISaveEditorsResult>;
     saveAll(options?: ISaveAllEditorsOptions): Promise<ISaveEditorsResult>;
-    revert(editors: IEditorIdentifier | IEditorIdentifier[], options?: IRevertOptions): Promise<boolean>;
+    revert(editors: IEditorIdentifier | readonly IEditorIdentifier[], options?: IRevertOptions): Promise<boolean>;
     revertAll(options?: IRevertAllEditorsOptions): Promise<boolean>;
     createScoped(editorGroupsContainer: IEditorGroupsContainer, disposables: DisposableStore): IEditorService;
 }

package/vscode/src/vs/workbench/services/environment/common/environmentService.service.d.ts

@@ -12,6 +12,7 @@ export interface IWorkbenchEnvironmentService extends IEnvironmentService {
     readonly skipWelcome: boolean;
     readonly disableWorkspaceTrust: boolean;
     readonly webviewExternalEndpoint: string;
+    readonly startupExperimentGroup?: string;
     readonly debugRenderer: boolean;
     readonly logExtensionHostCommunication?: boolean;
     readonly enableSmokeTestDriver?: boolean;

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProtocol.d.ts

@@ -25,6 +25,7 @@ export interface IExtensionHostInitData {
     version: string;
     quality: string | undefined;
     commit?: string;
+    date?: string;
     parentPid: number | 0;
     environment: IEnvironment;
     workspace?: IStaticWorkspaceData | null;