@codingame/monaco-vscode-api 15.0.2 → 16.0.0

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

@@ -344,18 +344,6 @@ export declare class TaskSorter {
     constructor(workspaceFolders: IWorkspaceFolder[]);
     compare(a: Task | ConfiguringTask, b: Task | ConfiguringTask): number;
 }
-export declare enum TaskEventKind {
-    DependsOnStarted = "dependsOnStarted",
-    AcquiredInput = "acquiredInput",
-    Start = "start",
-    ProcessStarted = "processStarted",
-    Active = "active",
-    Inactive = "inactive",
-    Changed = "changed",
-    Terminated = "terminated",
-    ProcessEnded = "processEnded",
-    End = "end"
-}
 export declare enum TaskRunType {
     SingleRun = "singleRun",
     Background = "background"
@@ -363,6 +351,21 @@ export declare enum TaskRunType {
 export interface ITaskChangedEvent {
     kind: TaskEventKind.Changed;
 }
+export declare enum TaskEventKind {
+    Changed = "changed",
+    ProcessStarted = "processStarted",
+    ProcessEnded = "processEnded",
+    Terminated = "terminated",
+    Start = "start",
+    AcquiredInput = "acquiredInput",
+    DependsOnStarted = "dependsOnStarted",
+    Active = "active",
+    Inactive = "inactive",
+    End = "end",
+    ProblemMatcherStarted = "problemMatcherStarted",
+    ProblemMatcherEnded = "problemMatcherEnded",
+    ProblemMatcherFoundErrors = "problemMatcherFoundErrors"
+}
 interface ITaskCommon {
     taskId: string;
     runType: TaskRunType;
@@ -390,11 +393,15 @@ export interface ITaskStartedEvent extends ITaskCommon {
     terminalId: number;
     resolvedVariables: Map<string, string>;
 }
+export interface ITaskProblemMatcherEndedEvent extends ITaskCommon {
+    kind: TaskEventKind.ProblemMatcherEnded;
+    hasErrors: boolean;
+}
 export interface ITaskGeneralEvent extends ITaskCommon {
-    kind: TaskEventKind.AcquiredInput | TaskEventKind.DependsOnStarted | TaskEventKind.Active | TaskEventKind.Inactive | TaskEventKind.End;
+    kind: TaskEventKind.AcquiredInput | TaskEventKind.DependsOnStarted | TaskEventKind.Active | TaskEventKind.Inactive | TaskEventKind.End | TaskEventKind.ProblemMatcherEnded | TaskEventKind.ProblemMatcherStarted | TaskEventKind.ProblemMatcherFoundErrors;
     terminalId: number | undefined;
 }
-export type ITaskEvent = ITaskChangedEvent | ITaskProcessStartedEvent | ITaskProcessEndedEvent | ITaskTerminatedEvent | ITaskStartedEvent | ITaskGeneralEvent;
+export type ITaskEvent = ITaskChangedEvent | ITaskProcessStartedEvent | ITaskProcessEndedEvent | ITaskTerminatedEvent | ITaskStartedEvent | ITaskGeneralEvent | ITaskProblemMatcherEndedEvent;
 export declare enum TaskRunSource {
     System = 0,
     User = 1,
@@ -407,7 +414,7 @@ export declare namespace TaskEvent {
     function processStarted(task: Task, terminalId: number, processId: number): ITaskProcessStartedEvent;
     function processEnded(task: Task, terminalId: number | undefined, exitCode: number | undefined): ITaskProcessEndedEvent;
     function terminated(task: Task, terminalId: number, exitReason: TerminalExitReason | undefined): ITaskTerminatedEvent;
-    function general(kind: TaskEventKind.AcquiredInput | TaskEventKind.DependsOnStarted | TaskEventKind.Active | TaskEventKind.Inactive | TaskEventKind.End, task: Task, terminalId?: number): ITaskGeneralEvent;
+    function general(kind: TaskEventKind.AcquiredInput | TaskEventKind.DependsOnStarted | TaskEventKind.Active | TaskEventKind.Inactive | TaskEventKind.End | TaskEventKind.ProblemMatcherEnded | TaskEventKind.ProblemMatcherStarted | TaskEventKind.ProblemMatcherFoundErrors, task: Task, terminalId?: number): ITaskGeneralEvent;
     function changed(): ITaskChangedEvent;
 }
 export declare namespace KeyedTaskIdentifier {

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

@@ -8,9 +8,9 @@ import { TaskDefinitionRegistry } from './taskDefinitionRegistry.js';
 import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
 
 const USER_TASKS_GROUP_KEY = 'settings';
-const TASK_RUNNING_STATE = ( new RawContextKey('taskRunning', false, ( localize(9672, "Whether a task is currently running."))));
-const TASK_TERMINAL_ACTIVE = ( new RawContextKey('taskTerminalActive', false, ( localize(9673, "Whether the active terminal is a task terminal."))));
-const TASKS_CATEGORY = ( localize2(9674, "Tasks"));
+const TASK_RUNNING_STATE = ( new RawContextKey('taskRunning', false, ( localize(9963, "Whether a task is currently running."))));
+const TASK_TERMINAL_ACTIVE = ( new RawContextKey('taskTerminalActive', false, ( localize(9964, "Whether the active terminal is a task terminal."))));
+const TASKS_CATEGORY = ( localize2(9965, "Tasks"));
 var ShellQuoting;
 (function (ShellQuoting) {
     ShellQuoting[ShellQuoting["Escape"] = 1] = "Escape";
@@ -587,24 +587,27 @@ class TaskSorter {
         }
     }
 }
+var TaskRunType;
+(function (TaskRunType) {
+    TaskRunType["SingleRun"] = "singleRun";
+    TaskRunType["Background"] = "background";
+})(TaskRunType || (TaskRunType = {}));
 var TaskEventKind;
 (function (TaskEventKind) {
-    TaskEventKind["DependsOnStarted"] = "dependsOnStarted";
-    TaskEventKind["AcquiredInput"] = "acquiredInput";
-    TaskEventKind["Start"] = "start";
+    TaskEventKind["Changed"] = "changed";
     TaskEventKind["ProcessStarted"] = "processStarted";
+    TaskEventKind["ProcessEnded"] = "processEnded";
+    TaskEventKind["Terminated"] = "terminated";
+    TaskEventKind["Start"] = "start";
+    TaskEventKind["AcquiredInput"] = "acquiredInput";
+    TaskEventKind["DependsOnStarted"] = "dependsOnStarted";
     TaskEventKind["Active"] = "active";
     TaskEventKind["Inactive"] = "inactive";
-    TaskEventKind["Changed"] = "changed";
-    TaskEventKind["Terminated"] = "terminated";
-    TaskEventKind["ProcessEnded"] = "processEnded";
     TaskEventKind["End"] = "end";
+    TaskEventKind["ProblemMatcherStarted"] = "problemMatcherStarted";
+    TaskEventKind["ProblemMatcherEnded"] = "problemMatcherEnded";
+    TaskEventKind["ProblemMatcherFoundErrors"] = "problemMatcherFoundErrors";
 })(TaskEventKind || (TaskEventKind = {}));
-var TaskRunType;
-(function (TaskRunType) {
-    TaskRunType["SingleRun"] = "singleRun";
-    TaskRunType["Background"] = "background";
-})(TaskRunType || (TaskRunType = {}));
 var TaskRunSource;
 (function (TaskRunSource) {
     TaskRunSource[TaskRunSource["System"] = 0] = "System";
@@ -762,7 +765,7 @@ var TaskDefinition;
                             break;
                         default:
                             reporter.error(( localize(
-                                9675,
+                                9966,
                                 'Error: the task identifier \'{0}\' is missing the required property \'{1}\'. The task identifier will be ignored.',
                                 JSON.stringify(external, undefined, 0),
                                 property

package/vscode/src/vs/workbench/contrib/testing/common/constants.js

@@ -27,19 +27,19 @@ var TestExplorerViewSorting;
     TestExplorerViewSorting["ByDuration"] = "duration";
 })(TestExplorerViewSorting || (TestExplorerViewSorting = {}));
 const testStateNames = {
-    [TestResultState.Errored]: ( localize(10615, 'Errored')),
-    [TestResultState.Failed]: ( localize(10616, 'Failed')),
-    [TestResultState.Passed]: ( localize(10617, 'Passed')),
-    [TestResultState.Queued]: ( localize(10618, 'Queued')),
-    [TestResultState.Running]: ( localize(10619, 'Running')),
-    [TestResultState.Skipped]: ( localize(10620, 'Skipped')),
-    [TestResultState.Unset]: ( localize(10621, 'Not yet run')),
+    [TestResultState.Errored]: ( localize(10937, 'Errored')),
+    [TestResultState.Failed]: ( localize(10938, 'Failed')),
+    [TestResultState.Passed]: ( localize(10939, 'Passed')),
+    [TestResultState.Queued]: ( localize(10940, 'Queued')),
+    [TestResultState.Running]: ( localize(10941, 'Running')),
+    [TestResultState.Skipped]: ( localize(10942, 'Skipped')),
+    [TestResultState.Unset]: ( localize(10943, 'Not yet run')),
 };
-const labelForTestInState = (label, state) => ( localize(10622, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(10944, '{0} ({1})', stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(10623, 'Debug')),
-    [TestRunProfileBitset.Run]: ( localize(10624, 'Run')),
-    [TestRunProfileBitset.Coverage]: ( localize(10625, 'Coverage')),
+    [TestRunProfileBitset.Debug]: ( localize(10945, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localize(10946, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localize(10947, 'Coverage')),
 };
 var TestCommandId;
 (function (TestCommandId) {

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -46,9 +46,9 @@ var TestRunProfileBitset;
     TestRunProfileBitset[TestRunProfileBitset["SupportsContinuousRun"] = 64] = "SupportsContinuousRun";
 })(TestRunProfileBitset || (TestRunProfileBitset = {}));
 const testProfileBitset = {
-    [TestRunProfileBitset.Run]: ( localize(10630, 'Run')),
-    [TestRunProfileBitset.Debug]: ( localize(10631, 'Debug')),
-    [TestRunProfileBitset.Coverage]: ( localize(10632, 'Coverage')),
+    [TestRunProfileBitset.Run]: ( localize(10952, 'Run')),
+    [TestRunProfileBitset.Debug]: ( localize(10953, 'Debug')),
+    [TestRunProfileBitset.Coverage]: ( localize(10954, 'Coverage')),
 };
 const testRunProfileBitsetList = [
     TestRunProfileBitset.Run,

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomainService.service.d.ts

@@ -1,6 +1,8 @@
+import { Event } from "../../../../base/common/event.js";
 import { URI } from "../../../../base/common/uri.js";
 export declare const ITrustedDomainService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITrustedDomainService>;
 export interface ITrustedDomainService {
     _serviceBrand: undefined;
+    onDidChangeTrustedDomains: Event<void>;
     isValid(resource: URI): boolean;
 }

package/vscode/src/vs/workbench/services/accounts/common/defaultAccount.d.ts

@@ -0,0 +1,67 @@
+import { Event } from "../../../../base/common/event.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IProductService } from "../../../../platform/product/common/productService.service.js";
+import { IAuthenticationService } from "../../authentication/common/authentication.service.js";
+import { IRequestService } from "../../../../platform/request/common/request.service.js";
+import { IExtensionService } from "../../extensions/common/extensions.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { IDefaultAccountService } from "./defaultAccount.service.js";
+export interface IDefaultAccount {
+    readonly sessionId: string;
+    readonly enterprise: boolean;
+    readonly access_type_sku?: string;
+    readonly assigned_date?: string;
+    readonly can_signup_for_limited?: boolean;
+    readonly chat_enabled?: boolean;
+    readonly chat_preview_features_enabled?: boolean;
+    readonly analytics_tracking_id?: string;
+    readonly limited_user_quotas?: {
+        readonly chat: number;
+        readonly completions: number;
+    };
+    readonly monthly_quotas?: {
+        readonly chat: number;
+        readonly completions: number;
+    };
+    readonly limited_user_reset_date?: string;
+}
+export declare class DefaultAccountService extends Disposable implements IDefaultAccountService {
+    _serviceBrand: undefined;
+    private _defaultAccount;
+    get defaultAccount(): IDefaultAccount | null;
+    private readonly initBarrier;
+    private readonly _onDidChangeDefaultAccount;
+    readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;
+    getDefaultAccount(): Promise<IDefaultAccount | null>;
+    setDefaultAccount(account: IDefaultAccount | null): void;
+}
+export declare class NullDefaultAccountService extends Disposable implements IDefaultAccountService {
+    _serviceBrand: undefined;
+    readonly onDidChangeDefaultAccount: Event<any>;
+    getDefaultAccount(): Promise<IDefaultAccount | null>;
+    setDefaultAccount(account: IDefaultAccount | null): void;
+}
+export declare class DefaultAccountManagementContribution extends Disposable implements IWorkbenchContribution {
+    private readonly defaultAccountService;
+    private readonly configurationService;
+    private readonly authenticationService;
+    private readonly extensionService;
+    private readonly productService;
+    private readonly requestService;
+    private readonly logService;
+    static ID: string;
+    private defaultAccount;
+    private readonly accountStatusContext;
+    constructor(defaultAccountService: IDefaultAccountService, configurationService: IConfigurationService, authenticationService: IAuthenticationService, extensionService: IExtensionService, productService: IProductService, requestService: IRequestService, logService: ILogService, contextKeyService: IContextKeyService);
+    private initialize;
+    private setDefaultAccount;
+    private extractFromToken;
+    private getDefaultAccountFromAuthenticatedSessions;
+    private scopesMatch;
+    private getTokenEntitlements;
+    private getChatEntitlements;
+    private registerSignInAction;
+}

package/vscode/src/vs/workbench/services/accounts/common/defaultAccount.js

@@ -0,0 +1,183 @@
+
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import { asJson } from '../../../../platform/request/common/request.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { localize } from '../../../../nls.js';
+import '../../../../base/common/async.js';
+import { getErrorMessage } from '../../../../base/common/errors.js';
+
+var DefaultAccountStatus;
+(function (DefaultAccountStatus) {
+    DefaultAccountStatus["Uninitialized"] = "uninitialized";
+    DefaultAccountStatus["Unavailable"] = "unavailable";
+    DefaultAccountStatus["Available"] = "available";
+})(DefaultAccountStatus || (DefaultAccountStatus = {}));
+const CONTEXT_DEFAULT_ACCOUNT_STATE = ( new RawContextKey('defaultAccountStatus', DefaultAccountStatus.Uninitialized));
+class NullDefaultAccountService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.onDidChangeDefaultAccount = Event.None;
+    }
+    async getDefaultAccount() {
+        return null;
+    }
+    setDefaultAccount(account) {
+    }
+}
+(class DefaultAccountManagementContribution extends Disposable {
+    static { this.ID = 'workbench.contributions.defaultAccountManagement'; }
+    constructor(defaultAccountService, configurationService, authenticationService, extensionService, productService, requestService, logService, contextKeyService) {
+        super();
+        this.defaultAccountService = defaultAccountService;
+        this.configurationService = configurationService;
+        this.authenticationService = authenticationService;
+        this.extensionService = extensionService;
+        this.productService = productService;
+        this.requestService = requestService;
+        this.logService = logService;
+        this.defaultAccount = null;
+        this.accountStatusContext = CONTEXT_DEFAULT_ACCOUNT_STATE.bindTo(contextKeyService);
+        this.initialize();
+    }
+    async initialize() {
+        if (!this.productService.defaultAccount) {
+            return;
+        }
+        const { authenticationProvider, tokenEntitlementUrl, chatEntitlementUrl } = this.productService.defaultAccount;
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const declaredProvider = this.authenticationService.declaredProviders.find(provider => provider.id === authenticationProvider.id);
+        if (!declaredProvider) {
+            this.logService.info(`Default account authentication provider ${authenticationProvider} is not declared.`);
+            return;
+        }
+        this.registerSignInAction(authenticationProvider.id, declaredProvider.label, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes);
+        this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider.id, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes, tokenEntitlementUrl, chatEntitlementUrl));
+        this._register(this.authenticationService.onDidChangeSessions(async (e) => {
+            if (e.providerId !== authenticationProvider.id && e.providerId !== authenticationProvider.enterpriseProviderId) {
+                return;
+            }
+            if (this.defaultAccount && e.event.removed?.some(session => session.id === this.defaultAccount?.sessionId)) {
+                this.setDefaultAccount(null);
+                return;
+            }
+            this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider.id, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes, tokenEntitlementUrl, chatEntitlementUrl));
+        }));
+    }
+    setDefaultAccount(account) {
+        this.defaultAccount = account;
+        this.defaultAccountService.setDefaultAccount(this.defaultAccount);
+        if (this.defaultAccount) {
+            this.accountStatusContext.set(DefaultAccountStatus.Available);
+        }
+        else {
+            this.accountStatusContext.set(DefaultAccountStatus.Unavailable);
+        }
+    }
+    extractFromToken(token, key) {
+        const result = ( new Map());
+        const firstPart = token?.split(':')[0];
+        const fields = firstPart?.split(';');
+        for (const field of fields) {
+            const [key, value] = field.split('=');
+            result.set(key, value);
+        }
+        return result.get(key);
+    }
+    async getDefaultAccountFromAuthenticatedSessions(authProviderId, enterpriseAuthProviderId, enterpriseAuthProviderConfig, scopes, tokenEntitlementUrl, chatEntitlementUrl) {
+        const id = this.configurationService.getValue(enterpriseAuthProviderConfig) ? enterpriseAuthProviderId : authProviderId;
+        const sessions = await this.authenticationService.getSessions(id, undefined, undefined, true);
+        const session = sessions.find(s => this.scopesMatch(s.scopes, scopes));
+        if (!session) {
+            return null;
+        }
+        const [chatEntitlements, tokenEntitlements] = await Promise.all([
+            this.getChatEntitlements(session.accessToken, chatEntitlementUrl),
+            this.getTokenEntitlements(session.accessToken, tokenEntitlementUrl)
+        ]);
+        return {
+            sessionId: session.id,
+            enterprise: id === enterpriseAuthProviderId || session.account.label.includes('_'),
+            ...chatEntitlements,
+            ...tokenEntitlements,
+        };
+    }
+    scopesMatch(scopes, expectedScopes) {
+        return scopes.length === expectedScopes.length && expectedScopes.every(scope => scopes.includes(scope));
+    }
+    async getTokenEntitlements(accessToken, tokenEntitlementsUrl) {
+        if (!tokenEntitlementsUrl) {
+            return {};
+        }
+        try {
+            const chatContext = await this.requestService.request({
+                type: 'GET',
+                url: tokenEntitlementsUrl,
+                disableCache: true,
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`
+                }
+            }, CancellationToken.None);
+            const chatData = await asJson(chatContext);
+            if (chatData) {
+                return {
+                    chat_preview_features_enabled: this.extractFromToken(chatData.token, 'editor_preview_features') !== '0',
+                };
+            }
+            this.logService.error('Failed to fetch token entitlements', 'No data returned');
+        }
+        catch (error) {
+            this.logService.error('Failed to fetch token entitlements', getErrorMessage(error));
+        }
+        return {};
+    }
+    async getChatEntitlements(accessToken, chatEntitlementsUrl) {
+        if (!chatEntitlementsUrl) {
+            return {};
+        }
+        try {
+            const context = await this.requestService.request({
+                type: 'GET',
+                url: chatEntitlementsUrl,
+                disableCache: true,
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`
+                }
+            }, CancellationToken.None);
+            const data = await asJson(context);
+            if (data) {
+                return data;
+            }
+            this.logService.error('Failed to fetch entitlements', 'No data returned');
+        }
+        catch (error) {
+            this.logService.error('Failed to fetch entitlements', getErrorMessage(error));
+        }
+        return {};
+    }
+    registerSignInAction(authProviderId, authProviderLabel, enterpriseAuthProviderId, enterpriseAuthProviderConfig, scopes) {
+        const that = this;
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.accounts.actions.signin',
+                    title: ( localize(11784, "Sign in to {0}", authProviderLabel)),
+                    menu: {
+                        id: MenuId.AccountsContext,
+                        when: ( ContextKeyExpr.and(( CONTEXT_DEFAULT_ACCOUNT_STATE.isEqualTo(DefaultAccountStatus.Unavailable)), ( ContextKeyExpr.has('config.extensions.gallery.serviceUrl')))),
+                        group: '0_signin',
+                    }
+                });
+            }
+            run() {
+                const id = that.configurationService.getValue(enterpriseAuthProviderConfig) ? enterpriseAuthProviderId : authProviderId;
+                return that.authenticationService.createSession(id, scopes);
+            }
+        }));
+    }
+});
+
+export { NullDefaultAccountService };

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

@@ -0,0 +1,9 @@
+import { Event } from "../../../../base/common/event.js";
+import { IDefaultAccount } from "./defaultAccount.js";
+export declare const IDefaultAccountService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IDefaultAccountService>;
+export interface IDefaultAccountService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeDefaultAccount: Event<IDefaultAccount | null>;
+    getDefaultAccount(): Promise<IDefaultAccount | null>;
+    setDefaultAccount(account: IDefaultAccount | null): void;
+}

package/vscode/src/vs/workbench/services/accounts/common/defaultAccount.service.js

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

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

@@ -52,6 +52,7 @@ export declare enum VariableKind {
     PathSeparator = "pathSeparator",
     PathSeparatorAlias = "/"
 }
+export declare const allVariableKinds: VariableKind[];
 export declare class VariableError extends ErrorNoTelemetry {
     readonly variable: VariableKind;
     constructor(variable: VariableKind, message?: string);

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

@@ -31,6 +31,7 @@ var VariableKind;
     VariableKind["PathSeparator"] = "pathSeparator";
     VariableKind["PathSeparatorAlias"] = "/";
 })(VariableKind || (VariableKind = {}));
+const allVariableKinds = ( Object.values(VariableKind)).filter((value) => typeof value === 'string');
 class VariableError extends ErrorNoTelemetry {
     constructor(variable, message) {
         super(message);
@@ -38,4 +39,4 @@ class VariableError extends ErrorNoTelemetry {
     }
 }
 
-export { VariableError, VariableKind };
+export { VariableError, VariableKind, allVariableKinds };

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

@@ -1,20 +1,15 @@
 import { IStringDictionary } from "../../../../base/common/collections.js";
 import { IProcessEnvironment } from "../../../../base/common/platform.js";
 import { ConfigurationTarget } from "../../../../platform/configuration/common/configuration.js";
-import { IWorkspaceFolder } from "../../../../platform/workspace/common/workspace.js";
+import { IWorkspaceFolderData } from "../../../../platform/workspace/common/workspace.js";
+import { ConfigurationResolverExpression } from "./configurationResolverExpression.js";
 export declare const IConfigurationResolverService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IConfigurationResolverService>;
 export interface IConfigurationResolverService {
     readonly _serviceBrand: undefined;
-    resolveWithEnvironment(environment: IProcessEnvironment, folder: IWorkspaceFolder | undefined, value: string): Promise<string>;
-    resolveAsync(folder: IWorkspaceFolder | undefined, value: string): Promise<string>;
-    resolveAsync(folder: IWorkspaceFolder | undefined, value: string[]): Promise<string[]>;
-    resolveAsync(folder: IWorkspaceFolder | undefined, value: IStringDictionary<string>): Promise<IStringDictionary<string>>;
-    resolveAnyAsync(folder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<any>;
-    resolveAnyMap(folder: IWorkspaceFolder | undefined, config: any, commandValueMapping?: IStringDictionary<string>): Promise<{
-        newConfig: any;
-        resolvedVariables: Map<string, string>;
-    }>;
-    resolveWithInteractionReplace(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<any>;
-    resolveWithInteraction(folder: IWorkspaceFolder | undefined, config: any, section?: string, variables?: IStringDictionary<string>, target?: ConfigurationTarget): Promise<Map<string, string> | undefined>;
+    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>;
     contributeVariable(variable: string, resolution: () => Promise<string | undefined>): void;
 }

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

@@ -0,0 +1,40 @@
+import { ConfiguredInput } from "./configurationResolver.js";
+export type Replacement = {
+    id: string;
+    inner: string;
+    name: string;
+    arg?: string;
+};
+interface IConfigurationResolverExpression<T> {
+    unresolved(): Iterable<Replacement>;
+    resolved(): Iterable<[
+        Replacement,
+        IResolvedValue
+    ]>;
+    resolve(replacement: Replacement, data: string | IResolvedValue): void;
+    toObject(): T;
+}
+export interface IResolvedValue {
+    value: string | undefined;
+    input?: ConfiguredInput;
+}
+export declare class ConfigurationResolverExpression<T> implements IConfigurationResolverExpression<T> {
+    static readonly VARIABLE_LHS = "${";
+    private locations;
+    private root;
+    private stringRoot;
+    private constructor();
+    static parse<T>(object: T): ConfigurationResolverExpression<T>;
+    private applyPlatformSpecificKeys;
+    private parseVariable;
+    private parseObject;
+    private parseString;
+    unresolved(): Iterable<Replacement>;
+    resolved(): Iterable<[
+        Replacement,
+        IResolvedValue
+    ]>;
+    resolve(replacement: Replacement, data: string | IResolvedValue): void;
+    toObject(): T;
+}
+export {};