@theia/core 1.65.0-next.6 → 1.65.1

package/src/common/preferences/preference-schema-service.ts

@@ -0,0 +1,434 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, named, postConstruct } from 'inversify';
+import { Disposable } from '../disposable';
+import { Emitter } from '../event';
+import { IJSONSchema } from '../json-schema';
+import { JSONObject, JSONValue } from '@lumino/coreutils';
+import { PreferenceDataProperty, PreferenceSchema, PreferenceSchemaService, DefaultValueChangedEvent, PreferenceContribution } from './preference-schema';
+import { PreferenceScope, ValidPreferenceScopes } from './preference-scope';
+import { PreferenceUtils } from './preference-provider';
+import { ContributionProvider } from '../contribution-provider';
+import { Deferred } from '../promise-util';
+
+const NO_OVERRIDE = {};
+const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
+
+@injectable()
+export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
+    // Storage structures
+    protected readonly schemas = new Set<PreferenceSchema>();
+    protected readonly properties = new Map<string, PreferenceDataProperty>();
+    /**
+     * This map stores default overrides. The primary map key is the base preference name.
+     * The preference name maps to a second map keyed by the override identifier or a special object value `NO_OVERRIDE',
+     * representing default overrides for the base property. The value in this second map is an array
+     * of entries in reverse order of their insertion. This is necessary becuaus multiple clients might register
+     * overrides for the same preference key/override combination. The elements in this array consist of a unique, generated
+     * identifier and the actual override value. This allows us to always return the last registerd override even
+     * when overrides are later removed.
+     */
+    protected readonly defaultOverrides = new Map<string, Map<string | object, [number, JSONValue][]>>();
+    protected readonly _overrideIdentifiers = new Set<string>();
+
+    protected readonly jsonSchemas: IJSONSchema[] = [];
+
+    protected readonly _ready = new Deferred();
+
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
+    get overrideIdentifiers(): ReadonlySet<string> {
+        return this._overrideIdentifiers;
+    }
+
+    getSchemaProperties(): ReadonlyMap<string, PreferenceDataProperty> {
+        return this.properties;
+    }
+
+    protected nextSchemaTitle = 1;
+    protected nextOverrideValueId = 1;
+
+    // Event emitters
+    protected readonly defaultValueChangedEmitter = new Emitter<DefaultValueChangedEvent>();
+    protected readonly schemaChangedEmitter = new Emitter<void>();
+
+    // Public events
+    readonly onDidChangeDefaultValue = this.defaultValueChangedEmitter.event;
+    readonly onDidChangeSchema = this.schemaChangedEmitter.event;
+
+    @inject(ValidPreferenceScopes)
+    readonly validScopes: readonly PreferenceScope[];
+
+    @inject(ContributionProvider) @named(PreferenceContribution)
+    protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;
+
+    @postConstruct()
+    protected init(): void {
+        for (const scope of this.validScopes) {
+            this.jsonSchemas[scope] = {
+                type: 'object',
+                properties: {},
+                patternProperties: {},
+                additionalProperties: false
+            };
+        }
+        const promises: Promise<void>[] = [];
+        this.preferenceContributions.getContributions().forEach(contrib => {
+            if (contrib.schema) {
+                this.addSchema(contrib.schema);
+            }
+            if (contrib.initSchema) {
+                promises.push(contrib.initSchema(this));
+            }
+        });
+        Promise.all(promises).then(() => this._ready.resolve());
+    }
+
+    dispose(): void {
+        this.defaultValueChangedEmitter.dispose();
+        this.schemaChangedEmitter.dispose();
+    }
+
+    registerOverrideIdentifier(overrideIdentifier: string): Disposable {
+        if (!this._overrideIdentifiers.has(overrideIdentifier)) {
+            this.addOverrideToJsonSchema(overrideIdentifier);
+            this._overrideIdentifiers.add(overrideIdentifier);
+            this.schemaChangedEmitter.fire();
+
+            return Disposable.create(() => {
+                if (this._overrideIdentifiers.delete(overrideIdentifier)) {
+                    this.schemaChangedEmitter.fire();
+                }
+            });
+        }
+        return Disposable.NULL;
+    }
+
+    addSchema(schema: PreferenceSchema): Disposable {
+        this.schemas.add(schema);
+
+        for (const [key, property] of Object.entries(schema.properties)) {
+            if (this.properties.has(key)) {
+                throw new Error(`Property with id '${key}' already exists`);
+            }
+
+            if (property.scope === undefined) {
+                property.scope = schema.scope;
+            }
+
+            if (property.overridable === undefined) {
+                property.overridable = schema.defaultOverridable;
+            }
+
+            this.properties.set(key, property);
+            this.setJSONSchemasProperty(key, property);
+            if (property.default !== undefined) {
+                this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, this.defaultOverrides.get(key), undefined, property.default!));
+            }
+
+        }
+
+        this.schemaChangedEmitter.fire();
+
+        return Disposable.create(() => {
+            if (this.schemas.delete(schema)) {
+                for (const [key, property] of Object.entries(schema.properties)) {
+                    this.deleteFromJSONSchemas(key, property);
+                    this.properties.delete(key);
+                    const overrides = this.defaultOverrides.get(key);
+
+                    const baseOverride = overrides?.get(NO_OVERRIDE);
+                    if (baseOverride !== undefined) {
+                        this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, overrides, baseOverride, undefined));
+                    } else if (property.default !== undefined) {
+                        this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, overrides, property.default, undefined));
+                    }
+                    if (overrides) {
+                        for (const [overrideKey, value] of overrides) {
+                            if (typeof overrideKey === 'string') {
+                                this.defaultValueChangedEmitter.fire(this.changeFor(key, overrideKey, overrides, value[0][1], undefined));
+                            }
+                        }
+                    }
+                }
+
+                this.schemaChangedEmitter.fire();
+            }
+        });
+    }
+
+    isValidInScope(preferenceName: string, scope: PreferenceScope): boolean {
+        const property = this.properties.get(preferenceName);
+
+        if (!property) {
+            return false;
+        }
+
+        // A property is valid in a scope if:
+        // 1. It is included (undefined or true)
+        // 2. Its scope is not defined (valid in all scopes) or its scope includes the given scope
+        return (property.included !== false) &&
+            (property.scope === undefined || property.scope >= scope);
+    }
+
+    getSchemaProperty(key: string): PreferenceDataProperty | undefined {
+        return this.properties.get(key);
+    }
+
+    updateSchemaProperty(key: string, property: PreferenceDataProperty): void {
+        const existing = this.properties.get(key);
+        if (existing) {
+            // Update the property with new values
+            const updatedProperty = { ...existing, ...property };
+            this.properties.set(key, updatedProperty);
+            const hasNoBaseOverrideValue = this.defaultOverrides.get(key)?.get(NO_OVERRIDE) === undefined;
+            if (hasNoBaseOverrideValue && !PreferenceUtils.deepEqual(property.default, existing.default)) {
+                this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, this.defaultOverrides.get(key), undefined, property.default!));
+            }
+
+            this.setJSONSchemasProperty(key, updatedProperty);
+            this.schemaChangedEmitter.fire();
+        } else {
+            console.warn(`Trying to update non-existent property ${key}`);
+        }
+    }
+
+    registerOverride(key: string, overrideIdentifier: string | undefined, value: JSONValue): Disposable {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const property = this.properties.get(key);
+        if (!property) {
+            console.warn(`Trying to register default override for non-existent preference: ${key}`);
+        } else if (!property.overridable && overrideIdentifier) {
+            console.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
+        }
+
+        let overrides = this.defaultOverrides.get(key);
+        if (!overrides) {
+            overrides = new Map();
+            this.defaultOverrides.set(key, overrides);
+        }
+
+        const oldValue = this.getDefaultValue(key, overrideIdentifier);
+
+        const overrideValueId = this.nextOverrideValueId;
+        let override = overrides.get(overrideId);
+        if (!override) {
+            override = [];
+            overrides.set(overrideId, override);
+        }
+        override.unshift([overrideValueId, value]);
+
+        // Fire event only if the value actually changed
+        if (!PreferenceUtils.deepEqual(oldValue, value)) {
+            const evt = this.changeFor(key, overrideIdentifier, overrides, oldValue, value);
+            this.defaultValueChangedEmitter.fire(evt);
+        }
+
+        if (property) {
+            this.setJSONSchemasProperty(key, property);
+        }
+
+        return Disposable.create(() => {
+            this.removeOverride(key, overrideIdentifier, overrideValueId);
+        });
+    }
+
+    protected changeFor(key: string, overrideIdentifier: string | undefined,
+        overrides: Map<string | object, [number, JSONValue][]> | undefined, oldValue: JSONValue | undefined, newValue: JSONValue | undefined): DefaultValueChangedEvent {
+        const affectedOverrides = [];
+        if (!overrideIdentifier) {
+            for (const id of this._overrideIdentifiers) {
+                if (!overrides?.has(id)) {
+                    affectedOverrides.push(id);
+                }
+            }
+        }
+        return {
+            key,
+            overrideIdentifier: overrideIdentifier,
+            otherAffectedOverrides: affectedOverrides,
+            oldValue,
+            newValue
+        };
+    }
+
+    protected removeOverride(key: string, overrideIdentifier: string | undefined, overrideValueId: number): void {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                const index = values.findIndex(v => v[0] === overrideValueId);
+                if (index) {
+                    const oldValue = this.getDefaultValue(key, overrideIdentifier);
+                    values.splice(index, 1);
+                    const newValue = this.getDefaultValue(key, overrideIdentifier);
+                    if (!PreferenceUtils.deepEqual(oldValue, newValue)) {
+
+                        const affectedOverrides = [];
+                        if (!overrideIdentifier) {
+                            for (const id of this._overrideIdentifiers) {
+                                if (!overrides.has(id)) {
+                                    affectedOverrides.push(id);
+                                }
+                            }
+                        }
+
+                        this.defaultValueChangedEmitter.fire({
+                            key,
+                            overrideIdentifier,
+                            otherAffectedOverrides: affectedOverrides,
+                            oldValue,
+                            newValue
+                        });
+                    }
+                }
+                if (values.length === 0) {
+                    overrides.delete(overrideId);
+                }
+            }
+            if (overrides.size === 0) {
+                this.defaultOverrides.delete(key);
+            }
+        }
+    }
+
+    getDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                return values[0][1]; // there will be no empty values arrays in the data structure
+            }
+        }
+
+        const property = this.properties.get(key);
+        return property?.default;
+    }
+
+    inspectDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                return values[0][1]; // there will be no empty values arrays in the data structure
+            }
+        }
+
+        if (!overrideIdentifier) {
+            const property = this.properties.get(key);
+            return property?.default;
+        }
+        return undefined;
+    }
+
+    getJSONSchema(scope: PreferenceScope): IJSONSchema {
+        return this.jsonSchemas[scope];
+    }
+
+    private setJSONSchemasProperty(key: string, property: PreferenceDataProperty): void {
+        for (const scope of this.validScopes) {
+            if (this.isValidInScope(key, scope)) {
+                this.setJSONSchemaProperty(this.jsonSchemas[scope], key, property);
+            }
+        }
+    }
+    private deleteFromJSONSchemas(key: string, property: PreferenceDataProperty): void {
+        for (const scope of this.validScopes) {
+            if (this.isValidInScope(key, scope)) {
+                const schema = this.jsonSchemas[scope];
+                for (const name of Object.keys(schema.properties!)) {
+                    if (name.match(OVERRIDE_PROPERTY)) {
+                        const value = schema.properties![name] as IJSONSchema;
+                        delete value.properties![key];
+                    } else {
+                        delete schema.properties![key];
+                    }
+                }
+            }
+        }
+    }
+
+    private setJSONSchemaProperty(schema: IJSONSchema, key: string, property: PreferenceDataProperty): void {
+        // Add property to the schema
+        const prop = { ...property, default: this.getDefaultValue(key, undefined) };
+        schema.properties![key] = prop;
+        delete prop['scope'];
+        delete prop['overridable'];
+        if (property.overridable) {
+            for (const overrideIdentifier of this._overrideIdentifiers) {
+                const overrideSchema: IJSONSchema = schema.properties![`[${overrideIdentifier}]`] || {
+                    type: 'object',
+                    properties: {},
+                    patternProperties: {},
+                    additionalProperties: false
+                };
+                schema.properties![`[${overrideIdentifier}]`] = overrideSchema;
+                overrideSchema.properties![key] = { ...property, default: this.getDefaultValue(key, overrideIdentifier) };
+            }
+        }
+    }
+
+    addOverrideToJsonSchema(overrideIdentifier: string): void {
+        for (const scope of this.validScopes) {
+            const schema = this.jsonSchemas[scope];
+            const overrideSchema: IJSONSchema = {
+                type: 'object',
+                properties: {},
+                patternProperties: {},
+                additionalProperties: false
+            };
+            schema.properties![`[${overrideIdentifier}]`] = overrideSchema;
+            for (const [key, property] of this.properties.entries()) {
+                if (property.overridable && this.isValidInScope(key, scope)) {
+                    overrideSchema.properties![key] = { ...property, default: this.getDefaultValue(key, overrideIdentifier) };
+                }
+            }
+        }
+    }
+
+    getDefaultValues(): JSONObject {
+        const result: JSONObject = {};
+
+        for (const [key, property] of this.properties.entries()) {
+            if (this.isValidInScope(key, PreferenceScope.Default)) {
+                if (property.default !== undefined) {
+                    result[key] = property.default;
+                }
+                const overrides = this.defaultOverrides.get(key);
+                if (overrides) {
+                    for (const [overrideId, values] of overrides.entries()) {
+                        if (overrideId === NO_OVERRIDE) {
+                            result[key] = values[0][1];
+                        } else {
+                            const overrideKey = `[${overrideId}]`;
+                            const target: JSONObject = result[overrideKey] as JSONObject || {};
+                            target[key] = values[0][1];
+                            result[overrideKey] = target;
+                        }
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+}

package/src/common/preferences/preference-schema.ts

@@ -16,89 +16,181 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { JSONValue } from '@lumino/coreutils';
+import { JSONObject, JSONValue } from '@lumino/coreutils';
 import { IJSONSchema } from '../json-schema';
 import { PreferenceScope } from './preference-scope';
-import { isObject, isString } from '../types';
+import { Event } from '../event';
+import { Disposable } from '../disposable';
 
-export interface PreferenceSchema {
-    [name: string]: any,
-    scope?: 'application' | 'window' | 'resource' | PreferenceScope,
-    overridable?: boolean;
+export const PreferenceContribution = Symbol('PreferenceContribution');
+/**
+ * A {@link PreferenceContribution} allows adding additional custom preferences.
+ * For this, the {@link PreferenceContribution} has to provide a valid `PrefernceSchema` specifying which preferences
+ * are available including their types and description.
+ *
+ * ### Example usage
+ * ```typescript
+ * const MyPreferencesSchema: PreferenceSchema = {
+ *     'scope': PreferenceScope.Folder,
+ *     'properties': {
+ *         'myext.decorations.enabled': {
+ *             'type': 'boolean',
+ *             'description': 'Show file status',
+ *             'default': true
+ *         },
+ *         // [...]
+ *     }
+ * }
+ * @injectable()
+ * export class MyPreferenceContribution implements PreferenceContribution{
+ *     schema= MyPreferencesSchema;
+ * }
+ * ```
+ */
+export interface PreferenceContribution {
+    readonly schema?: PreferenceSchema;
     /**
-     * The title of the preference schema.
-     * It is used in the preference UI to associate a localized group of preferences.
+     * Allows to do additional intialisation of the preference schema, for example registering overrides
+     * @param service the preference schema service
      */
-    title?: string;
-    properties: PreferenceSchemaProperties
-}
-export namespace PreferenceSchema {
-    export function is(obj: unknown): obj is PreferenceSchema {
-        return isObject<PreferenceSchema>(obj) && PreferenceSchemaProperties.is(obj.properties);
-    }
-    export function getDefaultScope(schema: PreferenceSchema): PreferenceScope {
-        let defaultScope: PreferenceScope = PreferenceScope.Workspace;
-        if (!PreferenceScope.is(schema.scope)) {
-            defaultScope = PreferenceScope.fromString(<string>schema.scope) || PreferenceScope.Workspace;
-        } else {
-            defaultScope = schema.scope;
-        }
-        return defaultScope;
-    }
+    initSchema?(service: PreferenceSchemaService): Promise<void>
 }
 
-export interface PreferenceSchemaProperties {
-    [name: string]: PreferenceSchemaProperty
-}
-export namespace PreferenceSchemaProperties {
-    export function is(obj: unknown): obj is PreferenceSchemaProperties {
-        return isObject(obj);
-    }
+export interface IndexedAccess<T> {
+    [name: string]: T;
 }
 
-export interface PreferenceDataSchema {
-    [name: string]: any,
+export interface PreferenceSchema {
+    /** The default scope for properties in this schema */
     scope?: PreferenceScope,
-    properties: {
-        [name: string]: PreferenceDataProperty
-    }
-    patternProperties: {
-        [name: string]: PreferenceDataProperty
-    };
+    /** Optional title to be used in UI */
+    title?: string,
+    /** Whether properties in this schema are overridable by default. Defaults to false. */
+    defaultOverridable?: boolean;
+    properties: IndexedAccess<PreferenceDataProperty>;
 }
 
-export interface PreferenceItem extends IJSONSchema {
+export interface PreferenceDataProperty extends IJSONSchema {
     /**
-     * preference default value, if `undefined` then `default`
+     * Whether distinct values can be defined for language override identifers. E.g. values valid when editing typescript files vs.
+     * when editing Java files
      */
-    defaultValue?: JSONValue;
     overridable?: boolean;
-    /** If false, the preference will not be included in the schema or the UI. */
+    /** If false, the preference will not be included in the schema or the UI. E.g. OS-Specific prefs */
     included?: boolean;
     /** If true, this item will registered as part of the preference schema, but hidden in the preference editor UI. */
     hidden?: boolean;
-    [key: string]: any;
-}
-export interface PreferenceSchemaProperty extends PreferenceItem {
-    description?: string;
-    markdownDescription?: string;
-    scope?: 'application' | 'machine' | 'window' | 'resource' | 'language-overridable' | 'machine-overridable' | PreferenceScope;
-    tags?: string[];
-}
-
-export interface PreferenceDataProperty extends PreferenceItem {
-    description?: string;
-    markdownDescription?: string;
+    /** The maximum scope where values for this property can be set. */
     scope?: PreferenceScope;
+    /** Metadata intended for custom renderers */
     typeDetails?: any;
+    /** Tags can be searched for in the UI */
+    tags?: string[]
 }
-export namespace PreferenceDataProperty {
-    export function fromPreferenceSchemaProperty(schemaProps: PreferenceSchemaProperty, defaultScope: PreferenceScope = PreferenceScope.Workspace): PreferenceDataProperty {
-        if (!schemaProps.scope) {
-            schemaProps.scope = defaultScope;
-        } else if (isString(schemaProps.scope)) {
-            return Object.assign(schemaProps, { scope: PreferenceScope.fromString(schemaProps.scope) || defaultScope });
-        }
-        return <PreferenceDataProperty>schemaProps;
-    }
+
+export interface DefaultValueChangedEvent {
+    /** The preference key */
+    key: string;
+    /** The override identifier that the default changed for */
+    overrideIdentifier?: string;
+    /**
+     * When the default for the base property changes, indicates which override identifiers will be affected
+     */
+    otherAffectedOverrides: string[];
+    oldValue: JSONValue | undefined;
+    newValue: JSONValue | undefined;
 }
+
+export const PreferenceSchemaService = Symbol('PreferenceSchemaService');
+
+export interface PreferenceSchemaService {
+    /**
+     * Resolves after static contributions have been processed
+     */
+    readonly ready: Promise<void>;
+    /**
+     * Register an override identifier for language specific preferences
+     * @param overrideIdentifier The identifier to register
+     * @returns A disposable to unregister the identifier
+     */
+    registerOverrideIdentifier(overrideIdentifier: string): Disposable;
+    readonly overrideIdentifiers: ReadonlySet<string>;
+
+    /**
+     * Add a preference schema. It is an error to register the same property in two different schemas
+     * @param schema The schema to add
+     * @returns A disposable to remove the schema
+     */
+    addSchema(schema: PreferenceSchema): Disposable;
+
+    /**
+     * The scopes which this preference schema service handles. Any properties that are not applicable within the
+     * valid scopes will be ignored
+     */
+    readonly validScopes: readonly PreferenceScope[];
+    /**
+     * Check if a preference is valid in a specific scope
+     * @param preferenceName The preference name
+     * @param scope The scope to check
+     * @returns True if the preference is valid in the given scope
+     */
+    isValidInScope(preferenceName: string, scope: PreferenceScope): boolean;
+    getSchemaProperty(key: string): PreferenceDataProperty | undefined;
+    getSchemaProperties(): ReadonlyMap<string, PreferenceDataProperty>;
+
+    /**
+     * Update a property in the schema. The corresponding JSON Schemas, etc. will be updated
+     * @param key The property key
+     * @param property The updated property
+     */
+    updateSchemaProperty(key: string, property: PreferenceDataProperty): void;
+
+    /**
+     * Register an override for a preference default value. If multiple overrides are registered for the same value,
+     * the last override will be in effect. Removing the last override will make the second-to-last override active, etc.
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @param value The default value
+     * @returns A disposable to unregister the override
+     */
+    registerOverride(key: string, overrideIdentifier: string | undefined, value: JSONValue): Disposable;
+    /**
+     * Get the default value for a preference. This is the value a client will see for the given key/override
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @returns The default value or undefined if not found
+     */
+    getDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined;
+    /**
+     * Gets the default value for a preference. This method not fall back to the global value if no override is given
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @returns The default value or undefined if not found
+     */
+    inspectDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined;
+
+    /**
+     * Gets a JSON schema a preference.json file for the given scope.
+     * @param scope The scope to generate schema for
+     * @returns The JSON schema
+     */
+    getJSONSchema(scope: PreferenceScope): IJSONSchema;
+    /**
+     * Get the collection of all defined default values as JSONObject of the form like in a preferences.json
+     *
+     * #### Example usage
+     * ```json
+     * {
+     *   "my.preference": "a string default",
+     *   "[typescript]": {
+     *      "another.preference": 39
+     *   }
+     * }
+     */
+    getDefaultValues(): JSONObject;
+
+    // Public events
+    onDidChangeDefaultValue: Event<DefaultValueChangedEvent>;
+    onDidChangeSchema: Event<void>;
+}
+