@codingame/monaco-vscode-configuration-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/services/configuration/browser/configuration.d.ts

@@ -0,0 +1,130 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { Event, Emitter } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ConfigurationModel, ConfigurationParseOptions, UserSettings } from "vscode/vscode/vs/platform/configuration/common/configurationModels";
+import { IConfigurationCache } from "@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration";
+import { IStoredWorkspaceFolder } from "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces";
+import { WorkbenchState, IWorkspaceFolder, IWorkspaceIdentifier } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IStringDictionary } from "vscode/vscode/vs/base/common/collections";
+import { IBrowserWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/browser/environmentService.service";
+import { DefaultConfiguration as BaseDefaultConfiguration } from "vscode/vscode/vs/platform/configuration/common/configurations";
+import { IJSONEditingService } from "vscode/vscode/vs/workbench/services/configuration/common/jsonEditing.service";
+import { IUserDataProfilesService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+export declare class DefaultConfiguration extends BaseDefaultConfiguration {
+    private readonly configurationCache;
+    static readonly DEFAULT_OVERRIDES_CACHE_EXISTS_KEY = "DefaultOverridesCacheExists";
+    private readonly configurationRegistry;
+    private cachedConfigurationDefaultsOverrides;
+    private readonly cacheKey;
+    private updateCache;
+    constructor(configurationCache: IConfigurationCache, environmentService: IBrowserWorkbenchEnvironmentService, logService: ILogService);
+    protected getConfigurationDefaultOverrides(): IStringDictionary<any>;
+    initialize(): Promise<ConfigurationModel>;
+    reload(): ConfigurationModel;
+    hasCachedConfigurationDefaultsOverrides(): boolean;
+    private initiaizeCachedConfigurationDefaultsOverridesPromise;
+    private initializeCachedConfigurationDefaultsOverrides;
+    protected onDidUpdateConfiguration(properties: string[], defaultsOverrides?: boolean): void;
+    private updateCachedConfigurationDefaultsOverrides;
+}
+export declare class ApplicationConfiguration extends UserSettings {
+    private readonly _onDidChangeConfiguration;
+    readonly onDidChangeConfiguration: Event<ConfigurationModel>;
+    private readonly reloadConfigurationScheduler;
+    constructor(userDataProfilesService: IUserDataProfilesService, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService);
+    initialize(): Promise<ConfigurationModel>;
+    loadConfiguration(): Promise<ConfigurationModel>;
+}
+export declare class UserConfiguration extends Disposable {
+    private settingsResource;
+    private tasksResource;
+    private configurationParseOptions;
+    private readonly fileService;
+    private readonly uriIdentityService;
+    private readonly logService;
+    private readonly _onDidChangeConfiguration;
+    readonly onDidChangeConfiguration: Event<ConfigurationModel>;
+    private readonly userConfiguration;
+    private readonly userConfigurationChangeDisposable;
+    private readonly reloadConfigurationScheduler;
+    get hasTasksLoaded(): boolean;
+    constructor(settingsResource: URI, tasksResource: URI | undefined, configurationParseOptions: ConfigurationParseOptions, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService);
+    reset(settingsResource: URI, tasksResource: URI | undefined, configurationParseOptions: ConfigurationParseOptions): Promise<ConfigurationModel>;
+    private doReset;
+    initialize(): Promise<ConfigurationModel>;
+    reload(settingsConfiguration?: ConfigurationModel): Promise<ConfigurationModel>;
+    reparse(parseOptions?: Partial<ConfigurationParseOptions>): ConfigurationModel;
+    getRestrictedSettings(): string[];
+}
+export declare class RemoteUserConfiguration extends Disposable {
+    private readonly _cachedConfiguration;
+    private readonly _fileService;
+    private _userConfiguration;
+    private _userConfigurationInitializationPromise;
+    private readonly _onDidChangeConfiguration;
+    readonly onDidChangeConfiguration: Event<ConfigurationModel>;
+    private readonly _onDidInitialize;
+    readonly onDidInitialize: Event<ConfigurationModel>;
+    constructor(remoteAuthority: string, configurationCache: IConfigurationCache, fileService: IFileService, uriIdentityService: IUriIdentityService, remoteAgentService: IRemoteAgentService, logService: ILogService);
+    initialize(): Promise<ConfigurationModel>;
+    reload(): Promise<ConfigurationModel>;
+    reparse(): ConfigurationModel;
+    getRestrictedSettings(): string[];
+    private onDidUserConfigurationChange;
+    private updateCache;
+}
+export declare class WorkspaceConfiguration extends Disposable {
+    private readonly configurationCache;
+    private readonly fileService;
+    private readonly uriIdentityService;
+    private readonly logService;
+    private readonly _cachedConfiguration;
+    private _workspaceConfiguration;
+    private readonly _workspaceConfigurationDisposables;
+    private _workspaceIdentifier;
+    private _isWorkspaceTrusted;
+    private readonly _onDidUpdateConfiguration;
+    readonly onDidUpdateConfiguration: Event<boolean>;
+    private _initialized;
+    get initialized(): boolean;
+    constructor(configurationCache: IConfigurationCache, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService);
+    initialize(workspaceIdentifier: IWorkspaceIdentifier, workspaceTrusted: boolean): Promise<void>;
+    reload(): Promise<void>;
+    getFolders(): IStoredWorkspaceFolder[];
+    setFolders(folders: IStoredWorkspaceFolder[], jsonEditingService: IJSONEditingService): Promise<void>;
+    isTransient(): boolean;
+    getConfiguration(): ConfigurationModel;
+    updateWorkspaceTrust(trusted: boolean): ConfigurationModel;
+    reparseWorkspaceSettings(): ConfigurationModel;
+    getRestrictedSettings(): string[];
+    private waitAndInitialize;
+    private doInitialize;
+    private isUntrusted;
+    private onDidWorkspaceConfigurationChange;
+    private updateCache;
+}
+export declare class FolderConfiguration extends Disposable {
+    readonly workspaceFolder: IWorkspaceFolder;
+    private readonly workbenchState;
+    private workspaceTrusted;
+    private readonly configurationCache;
+    protected readonly _onDidChange: Emitter<void>;
+    readonly onDidChange: Event<void>;
+    private folderConfiguration;
+    private readonly scopes;
+    private readonly configurationFolder;
+    private cachedFolderConfiguration;
+    constructor(useCache: boolean, workspaceFolder: IWorkspaceFolder, configFolderRelativePath: string, workbenchState: WorkbenchState, workspaceTrusted: boolean, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService, configurationCache: IConfigurationCache);
+    loadConfiguration(): Promise<ConfigurationModel>;
+    updateWorkspaceTrust(trusted: boolean): ConfigurationModel;
+    reparse(): ConfigurationModel;
+    getRestrictedSettings(): string[];
+    private isUntrusted;
+    private onDidFolderConfigurationChange;
+    private createFileServiceBasedConfiguration;
+    private updateCache;
+}

package/vscode/src/vs/workbench/services/configuration/browser/configuration.js

@@ -1,12 +1,14 @@
+
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { getErrorMessage } from 'vscode/vscode/vs/base/common/errors';
 import { Disposable, MutableDisposable, combinedDisposable, toDisposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileOperationResult, FileChangeType, FileOperation, whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
 import { UserSettings, ConfigurationModelParser, ConfigurationModel } from 'vscode/vscode/vs/platform/configuration/common/configurationModels';
 import { StandaloneConfigurationModelParser, WorkspaceConfigurationModelParser } from '../common/configurationModels.js';
-import { APPLY_ALL_PROFILES_SETTING, TASKS_CONFIGURATION_KEY, REMOTE_MACHINE_SCOPES, WORKSPACE_SCOPES, FOLDER_SETTINGS_NAME, FOLDER_SCOPES, LAUNCH_CONFIGURATION_KEY } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
-import { Extensions, OVERRIDE_PROPERTY_REGEX } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { APPLY_ALL_PROFILES_SETTING, TASKS_CONFIGURATION_KEY, REMOTE_MACHINE_SCOPES, WORKSPACE_SCOPES, FOLDER_SETTINGS_NAME, FOLDER_SCOPES, LAUNCH_CONFIGURATION_KEY } from '@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration';
+import { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { Extensions, OVERRIDE_PROPERTY_REGEX, ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { equals } from 'vscode/vscode/vs/base/common/objects';
 import { hash } from 'vscode/vscode/vs/base/common/hash';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
@@ -92,7 +94,7 @@ class DefaultConfiguration extends DefaultConfiguration$1 {
 }
 class ApplicationConfiguration extends UserSettings {
     constructor(userDataProfilesService, fileService, uriIdentityService, logService) {
-        super(userDataProfilesService.defaultProfile.settingsResource, { scopes: [1 ] }, uriIdentityService.extUri, fileService, logService);
+        super(userDataProfilesService.defaultProfile.settingsResource, { scopes: [ConfigurationScope.APPLICATION], skipUnregistered: true }, uriIdentityService.extUri, fileService, logService);
         this._onDidChangeConfiguration = this._register(( new Emitter()));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
         this._register(this.onDidChange(() => this.reloadConfigurationScheduler.schedule()));
@@ -204,8 +206,8 @@ class FileServiceBasedConfiguration extends Disposable {
                 }
                 catch (error) {
                     this.logService.trace(`Error while resolving configuration file '${( resource.toString())}': ${getErrorMessage(error)}`);
-                    if (error.fileOperationResult !== 1
-                        && error.fileOperationResult !== 9 ) {
+                    if (error.fileOperationResult !== FileOperationResult.FILE_NOT_FOUND
+                        && error.fileOperationResult !== FileOperationResult.FILE_NOT_DIRECTORY) {
                         this.logService.error(error);
                     }
                 }
@@ -258,20 +260,20 @@ class FileServiceBasedConfiguration extends Disposable {
             return true;
         }
         if (( this.allResources.some(
-            resource => event.contains(this.uriIdentityService.extUri.dirname(resource), 2 )
+            resource => event.contains(this.uriIdentityService.extUri.dirname(resource), FileChangeType.DELETED)
         ))) {
             return true;
         }
         return false;
     }
     handleFileOperationEvent(event) {
-        if ((event.isOperation(0 ) || event.isOperation(3 ) || event.isOperation(1 ) || event.isOperation(4 ))
+        if ((event.isOperation(FileOperation.CREATE) || event.isOperation(FileOperation.COPY) || event.isOperation(FileOperation.DELETE) || event.isOperation(FileOperation.WRITE))
             && ( this.allResources.some(
             resource => this.uriIdentityService.extUri.isEqual(event.resource, resource)
         ))) {
             return true;
         }
-        if (event.isOperation(1 ) && ( this.allResources.some(
+        if (event.isOperation(FileOperation.DELETE) && ( this.allResources.some(
             resource => this.uriIdentityService.extUri.isEqual(event.resource, this.uriIdentityService.extUri.dirname(resource))
         ))) {
             return true;
@@ -344,7 +346,7 @@ class RemoteUserConfiguration extends Disposable {
                 content = await this._userConfiguration.resolveContent();
             }
             catch (error) {
-                if (error.fileOperationResult !== 1 ) {
+                if (error.fileOperationResult !== FileOperationResult.FILE_NOT_FOUND) {
                     return;
                 }
             }
@@ -418,15 +420,15 @@ class FileServiceBasedRemoteUserConfiguration extends Disposable {
     }
     handleFileChangesEvent(event) {
         let affectedByChanges = false;
-        if (event.contains(this.configurationResource, 1 )) {
+        if (event.contains(this.configurationResource, FileChangeType.ADDED)) {
             affectedByChanges = true;
             this.onResourceExists(true);
         }
-        else if (event.contains(this.configurationResource, 2 )) {
+        else if (event.contains(this.configurationResource, FileChangeType.DELETED)) {
             affectedByChanges = true;
             this.onResourceExists(false);
         }
-        else if (event.contains(this.configurationResource, 0 )) {
+        else if (event.contains(this.configurationResource, FileChangeType.UPDATED)) {
             affectedByChanges = true;
         }
         if (affectedByChanges) {
@@ -434,7 +436,7 @@ class FileServiceBasedRemoteUserConfiguration extends Disposable {
         }
     }
     handleFileOperationEvent(event) {
-        if ((event.isOperation(0 ) || event.isOperation(3 ) || event.isOperation(1 ) || event.isOperation(4 ))
+        if ((event.isOperation(FileOperation.CREATE) || event.isOperation(FileOperation.COPY) || event.isOperation(FileOperation.DELETE) || event.isOperation(FileOperation.WRITE))
             && this.uriIdentityService.extUri.isEqual(event.resource, this.configurationResource)) {
             this.reloadConfigurationScheduler.schedule();
         }
@@ -602,7 +604,7 @@ class FileServiceBasedWorkspaceConfiguration extends Disposable {
         this.onDidChange = this._onDidChange.event;
         this.workspaceConfigurationModelParser = ( new WorkspaceConfigurationModelParser('', logService));
         this.workspaceSettings = ConfigurationModel.createEmptyModel(logService);
-        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => !!this._workspaceIdentifier && e.contains(this._workspaceIdentifier.configPath)), Event.filter(this.fileService.onDidRunOperation, e => !!this._workspaceIdentifier && (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && uriIdentityService.extUri.isEqual(e.resource, this._workspaceIdentifier.configPath)))(() => this.reloadConfigurationScheduler.schedule()));
+        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => !!this._workspaceIdentifier && e.contains(this._workspaceIdentifier.configPath)), Event.filter(this.fileService.onDidRunOperation, e => !!this._workspaceIdentifier && (e.isOperation(FileOperation.CREATE) || e.isOperation(FileOperation.COPY) || e.isOperation(FileOperation.DELETE) || e.isOperation(FileOperation.WRITE)) && uriIdentityService.extUri.isEqual(e.resource, this._workspaceIdentifier.configPath)))(() => this.reloadConfigurationScheduler.schedule()));
         this.reloadConfigurationScheduler = this._register(( new RunOnceScheduler(() => this._onDidChange.fire(), 50)));
         this.workspaceConfigWatcher = this._register(this.watchWorkspaceConfigurationFile());
     }
@@ -803,7 +805,7 @@ class FolderConfiguration extends Disposable {
         this.configurationCache = configurationCache;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this.scopes = 3  === this.workbenchState ? FOLDER_SCOPES : WORKSPACE_SCOPES;
+        this.scopes = WorkbenchState.WORKSPACE === this.workbenchState ? FOLDER_SCOPES : WORKSPACE_SCOPES;
         this.configurationFolder = uriIdentityService.extUri.joinPath(workspaceFolder.uri, configFolderRelativePath);
         this.cachedFolderConfiguration = ( new CachedFolderConfiguration(
             workspaceFolder.uri,

package/vscode/src/vs/workbench/services/configuration/browser/configurationService.d.ts

@@ -0,0 +1,144 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { Event, Emitter } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Workspace as BaseWorkspace, WorkbenchState, IWorkspaceFolder, IWorkspaceFoldersChangeEvent, IWorkspaceFoldersWillChangeEvent, ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier, IAnyWorkspaceIdentifier } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { ConfigurationModel } from "vscode/vscode/vs/platform/configuration/common/configurationModels";
+import { IConfigurationChangeEvent, ConfigurationTarget, IConfigurationOverrides, IConfigurationData, IConfigurationValue, IConfigurationUpdateOverrides, IConfigurationUpdateOptions } from "vscode/vscode/vs/platform/configuration/common/configuration";
+import { IConfigurationCache, RestrictedSettings } from "@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration";
+import { IWorkbenchConfigurationService } from "@codingame/monaco-vscode-422642f2-7e3a-5c1c-9e1e-1d3ef1817346-common/vscode/vs/workbench/services/configuration/common/configuration.service";
+import { IWorkspaceFolderCreationData } from "@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/platform/workspaces/common/workspaces";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IUserDataProfileService } from "vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { IPolicyService } from "vscode/vscode/vs/platform/policy/common/policy.service";
+import { IUserDataProfilesService } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+import { IBrowserWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/browser/environmentService.service";
+declare class Workspace extends BaseWorkspace {
+    initialized: boolean;
+}
+export declare class WorkspaceService extends Disposable implements IWorkbenchConfigurationService, IWorkspaceContextService {
+    private readonly userDataProfileService;
+    private readonly userDataProfilesService;
+    private readonly fileService;
+    private readonly remoteAgentService;
+    private readonly uriIdentityService;
+    private readonly logService;
+    _serviceBrand: undefined;
+    private workspace;
+    private initRemoteUserConfigurationBarrier;
+    private completeWorkspaceBarrier;
+    private readonly configurationCache;
+    private _configuration;
+    private initialized;
+    private readonly defaultConfiguration;
+    private readonly policyConfiguration;
+    private applicationConfiguration;
+    private readonly applicationConfigurationDisposables;
+    private readonly localUserConfiguration;
+    private readonly remoteUserConfiguration;
+    private readonly workspaceConfiguration;
+    private cachedFolderConfigs;
+    private readonly workspaceEditingQueue;
+    private readonly _onDidChangeConfiguration;
+    readonly onDidChangeConfiguration: Event<IConfigurationChangeEvent>;
+    protected readonly _onWillChangeWorkspaceFolders: Emitter<IWorkspaceFoldersWillChangeEvent>;
+    readonly onWillChangeWorkspaceFolders: Event<IWorkspaceFoldersWillChangeEvent>;
+    private readonly _onDidChangeWorkspaceFolders;
+    readonly onDidChangeWorkspaceFolders: Event<IWorkspaceFoldersChangeEvent>;
+    private readonly _onDidChangeWorkspaceName;
+    readonly onDidChangeWorkspaceName: Event<void>;
+    private readonly _onDidChangeWorkbenchState;
+    readonly onDidChangeWorkbenchState: Event<WorkbenchState>;
+    private isWorkspaceTrusted;
+    private _restrictedSettings;
+    get restrictedSettings(): RestrictedSettings;
+    private readonly _onDidChangeRestrictedSettings;
+    readonly onDidChangeRestrictedSettings: Event<RestrictedSettings>;
+    private readonly configurationRegistry;
+    private instantiationService;
+    private configurationEditing;
+    constructor({ remoteAuthority, configurationCache }: {
+        remoteAuthority?: string;
+        configurationCache: IConfigurationCache;
+    }, environmentService: IBrowserWorkbenchEnvironmentService, userDataProfileService: IUserDataProfileService, userDataProfilesService: IUserDataProfilesService, fileService: IFileService, remoteAgentService: IRemoteAgentService, uriIdentityService: IUriIdentityService, logService: ILogService, policyService: IPolicyService);
+    private createApplicationConfiguration;
+    getCompleteWorkspace(): Promise<Workspace>;
+    getWorkspace(): Workspace;
+    getWorkbenchState(): WorkbenchState;
+    getWorkspaceFolder(resource: URI): IWorkspaceFolder | null;
+    addFolders(foldersToAdd: IWorkspaceFolderCreationData[], index?: number): Promise<void>;
+    removeFolders(foldersToRemove: URI[]): Promise<void>;
+    updateFolders(foldersToAdd: IWorkspaceFolderCreationData[], foldersToRemove: URI[], index?: number): Promise<void>;
+    isInsideWorkspace(resource: URI): boolean;
+    isCurrentWorkspace(workspaceIdOrFolder: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | URI): boolean;
+    private doUpdateFolders;
+    private setFolders;
+    private contains;
+    getConfigurationData(): IConfigurationData;
+    getValue<T>(): T;
+    getValue<T>(section: string): T;
+    getValue<T>(overrides: IConfigurationOverrides): T;
+    getValue<T>(section: string, overrides: IConfigurationOverrides): T;
+    updateValue(key: string, value: any): Promise<void>;
+    updateValue(key: string, value: any, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides): Promise<void>;
+    updateValue(key: string, value: any, target: ConfigurationTarget): Promise<void>;
+    updateValue(key: string, value: any, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides, target: ConfigurationTarget, options?: IConfigurationUpdateOptions): Promise<void>;
+    reloadConfiguration(target?: ConfigurationTarget | IWorkspaceFolder): Promise<void>;
+    hasCachedConfigurationDefaultsOverrides(): boolean;
+    inspect<T>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<T>;
+    keys(): {
+        default: string[];
+        user: string[];
+        workspace: string[];
+        workspaceFolder: string[];
+    };
+    whenRemoteConfigurationLoaded(): Promise<void>;
+    initialize(arg: IAnyWorkspaceIdentifier): Promise<void>;
+    updateWorkspaceTrust(trusted: boolean): void;
+    acquireInstantiationService(instantiationService: IInstantiationService): void;
+    isSettingAppliedForAllProfiles(key: string): boolean;
+    private createWorkspace;
+    private createMultiFolderWorkspace;
+    private createSingleFolderWorkspace;
+    private createEmptyWorkspace;
+    private checkAndMarkWorkspaceComplete;
+    private updateWorkspaceAndInitializeConfiguration;
+    private compareFolders;
+    private initializeConfiguration;
+    private reloadDefaultConfiguration;
+    private reloadApplicationConfiguration;
+    private reloadUserConfiguration;
+    reloadLocalUserConfiguration(donotTrigger?: boolean, settingsConfiguration?: ConfigurationModel): Promise<ConfigurationModel>;
+    private reloadRemoteUserConfiguration;
+    private reloadWorkspaceConfiguration;
+    private reloadWorkspaceFolderConfiguration;
+    private loadConfiguration;
+    private getWorkspaceConfigurationModel;
+    private onUserDataProfileChanged;
+    private onDefaultConfigurationChanged;
+    private onPolicyConfigurationChanged;
+    private onApplicationConfigurationChanged;
+    private onLocalUserConfigurationChanged;
+    private onRemoteUserConfigurationChanged;
+    private onWorkspaceConfigurationChanged;
+    private updateRestrictedSettings;
+    private updateWorkspaceConfiguration;
+    private handleWillChangeWorkspaceFolders;
+    private onWorkspaceFolderConfigurationChanged;
+    private onFoldersChanged;
+    private loadFolderConfigurations;
+    private validateWorkspaceFoldersAndReload;
+    private toValidWorkspaceFolders;
+    private writeConfigurationValue;
+    private createConfigurationEditingService;
+    private getConfigurationModelForEditableConfigurationTarget;
+    getConfigurationModel(target: ConfigurationTarget, resource?: URI | null): ConfigurationModel | undefined;
+    private deriveConfigurationTargets;
+    private triggerConfigurationChange;
+    private toEditableConfigurationTarget;
+}
+export {};