@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/service-override/configuration.d.ts

@@ -1,592 +1,13 @@
 import * as vscode from 'vscode';
-import * as monaco from 'monaco-editor';
-
-/**
- * An object that performs a cleanup operation when `.dispose()` is called.
- *
- * Some examples of how disposables are used:
- *
- * - An event listener that removes itself when `.dispose()` is called.
- * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
- * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
- */
-interface IDisposable {
-    dispose(): void;
-}
-/**
- * Manages a collection of disposable values.
- *
- * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
- * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
- * store that has already been disposed of.
- */
-declare class DisposableStore implements IDisposable {
-    static DISABLE_DISPOSED_WARNING: boolean;
-    private readonly _toDispose;
-    private _isDisposed;
-    constructor();
-    /**
-     * Dispose of all registered disposables and mark this object as disposed.
-     *
-     * Any future disposables added to this object will be disposed of on `add`.
-     */
-    dispose(): void;
-    /**
-     * @return `true` if this object has been disposed of.
-     */
-    get isDisposed(): boolean;
-    /**
-     * Dispose of all registered disposables but do not mark this object as disposed.
-     */
-    clear(): void;
-    /**
-     * Add a new {@link IDisposable disposable} to the collection.
-     */
-    add<T extends IDisposable>(o: T): T;
-}
-
-interface IObservable<T, TChange = void> {
-    readonly TChange: TChange;
-    /**
-     * Reads the current value.
-     *
-     * Must not be called from {@link IObserver.handleChange}.
-     */
-    get(): T;
-    /**
-     * Adds an observer.
-     */
-    addObserver(observer: IObserver): void;
-    removeObserver(observer: IObserver): void;
-    /**
-     * Subscribes the reader to this observable and returns the current value of this observable.
-     */
-    read(reader: IReader): T;
-    map<TNew>(fn: (value: T) => TNew): IObservable<TNew>;
-    readonly debugName: string;
-}
-interface IReader {
-    /**
-     * Reports an observable that was read.
-     *
-     * Is called by {@link IObservable.read}.
-     */
-    subscribeTo<T>(observable: IObservable<T, any>): void;
-}
-interface IObserver {
-    /**
-     * Indicates that an update operation is about to begin.
-     *
-     * During an update, invariants might not hold for subscribed observables and
-     * change events might be delayed.
-     * However, all changes must be reported before all update operations are over.
-     */
-    beginUpdate<T>(observable: IObservable<T>): void;
-    /**
-     * Is called by a subscribed observable immediately after it notices a change.
-     *
-     * When {@link IObservable.get} returns and no change has been reported,
-     * there has been no change for that observable.
-     *
-     * Implementations must not call into other observables!
-     * The change should be processed when {@link IObserver.endUpdate} is called.
-     */
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
-    /**
-     * Indicates that an update operation has completed.
-     */
-    endUpdate<T>(observable: IObservable<T>): void;
-}
-
-/**
- * Can be passed into the Delayed to defer using a microtask
- * */
-declare const MicrotaskDelay: unique symbol;
-
-/**
- * An event with zero or one parameters that can be subscribed to. The event is a function itself.
- */
-type Event<T> = vscode.Event<T>
-declare namespace Event {
-    const None: Event<any>;
-    /**
-     * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
-     * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
-     * result of merging events and to try prevent race conditions that could arise when using related deferred and
-     * non-deferred events.
-     *
-     * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
-     * (eg. latency of keypress to text rendered).
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
-    /**
-     * Given an event, returns another event which only fires once.
-     *
-     * @param event The event source for the new event.
-     */
-    function once<T>(event: Event<T>): Event<T>;
-    /**
-     * Maps an event of one type into an event of another type using a mapping function, similar to how
-     * `Array.prototype.map` works.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param map The mapping function.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
-    /**
-     * Wraps an event in another event that performs some function on the event object before firing.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param each The function to perform on the event object.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
-    /**
-     * Wraps an event in another event that fires only when some condition is met.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param filter The filter function that defines the condition. The event will fire for the object if this function
-     * returns true.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
-    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
-    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
-    /**
-     * Given an event, returns the same event but typed as `Event<void>`.
-     */
-    function signal<T>(event: Event<T>): Event<void>;
-    /**
-     * Given a collection of events, returns a single event which emits whenever any of the provided events emit.
-     */
-    function any<T>(...events: Event<T>[]): Event<T>;
-    function any(...events: Event<any>[]): Event<void>;
-    /**
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     */
-    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
-    /**
-     * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an
-     * array event object of all events that fired.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The original event to debounce.
-     * @param merge A function that reduces all events into a single event.
-     * @param delay The number of milliseconds to debounce.
-     * @param leading Whether to fire a leading event without debouncing.
-     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
-     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
-     * listener gets disposed before the debounced event fires.
-     * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
-     * @param disposable A disposable store to register the debounce emitter to.
-     */
-    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
-    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
-    /**
-     * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     */
-    function accumulate<T>(event: Event<T>, delay?: number, disposable?: DisposableStore): Event<T[]>;
-    /**
-     * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
-     * event objects from different sources do not fire the same event object.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param equals The equality condition.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     *
-     * @example
-     * ```
-     * // Fire only one time when a single window is opened or focused
-     * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))
-     * ```
-     */
-    function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
-    /**
-     * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @example
-     * ```
-     * const event = new EventEmitter<number | undefined>().event;
-     * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
-     * ```
-     *
-     * @param event The event source for the new event.
-     * @param isT A function that determines what event is of the first type.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
-    /**
-     * Buffers an event until it has a listener attached.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a
-     * `setTimeout` when the first event listener is added.
-     * @param _buffer Internal: A source event array used for tests.
-     *
-     * @example
-     * ```
-     * // Start accumulating events, when the first listener is attached, flush
-     * // the event after a timeout such that multiple listeners attached before
-     * // the timeout would receive the event
-     * this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
-     * ```
-     */
-    function buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
-    interface IChainableEvent<T> extends IDisposable {
-        event: Event<T>;
-        map<O>(fn: (i: T) => O): IChainableEvent<O>;
-        forEach(fn: (i: T) => void): IChainableEvent<T>;
-        filter(fn: (e: T) => boolean): IChainableEvent<T>;
-        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
-        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
-        latch(): IChainableEvent<T>;
-        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
-        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
-        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
-        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
-    }
-    /**
-     * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.
-     *
-     * @example
-     * ```
-     * // Normal
-     * const onEnterPressNormal = Event.filter(
-     *   Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),
-     *   e.keyCode === KeyCode.Enter
-     * ).event;
-     *
-     * // Using chain
-     * const onEnterPressChain = Event.chain(onKeyPress.event)
-     *   .map(e => new StandardKeyboardEvent(e))
-     *   .filter(e => e.keyCode === KeyCode.Enter)
-     *   .event;
-     * ```
-     */
-    function chain<T>(event: Event<T>): IChainableEvent<T>;
-    interface NodeEventEmitter {
-        on(event: string | symbol, listener: Function): unknown;
-        removeListener(event: string | symbol, listener: Function): unknown;
-    }
-    /**
-     * Creates an {@link Event} from a node event emitter.
-     */
-    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    interface DOMEventEmitter {
-        addEventListener(event: string | symbol, listener: Function): void;
-        removeEventListener(event: string | symbol, listener: Function): void;
-    }
-    /**
-     * Creates an {@link Event} from a DOM event emitter.
-     */
-    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    /**
-     * Creates a promise out of an event, using the {@link Event.once} helper.
-     */
-    function toPromise<T>(event: Event<T>): Promise<T>;
-    /**
-     * Adds a listener to an event and calls the listener immediately with undefined as the event object.
-     *
-     * @example
-     * ```
-     * // Initialize the UI and update it when dataChangeEvent fires
-     * runAndSubscribe(dataChangeEvent, () => this._updateUI());
-     * ```
-     */
-    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
-    /**
-     * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new
-     * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed.
-     */
-    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
-    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
-}
-
-/**
- * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
- * This class is a simple parser which creates the basic component parts
- * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
- * and encoding.
- *
- * ```txt
- *       foo://example.com:8042/over/there?name=ferret#nose
- *       \_/   \______________/\_________/ \_________/ \__/
- *        |           |            |            |        |
- *     scheme     authority       path        query   fragment
- *        |   _____________________|__
- *       / \ /                        \
- *       urn:example:animal:ferret:nose
- * ```
- */
-declare class URI implements UriComponents {
-    static isUri(thing: any): thing is URI;
-    /**
-     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part before the first colon.
-     */
-    readonly scheme: string;
-    /**
-     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part between the first double slashes and the next slash.
-     */
-    readonly authority: string;
-    /**
-     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly path: string;
-    /**
-     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly query: string;
-    /**
-     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly fragment: string;
-    /**
-     * @internal
-     */
-    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
-    /**
-     * @internal
-     */
-    protected constructor(components: UriComponents);
-    /**
-     * Returns a string representing the corresponding file system path of this URI.
-     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
-     * platform specific path separator.
-     *
-     * * Will *not* validate the path for invalid characters and semantics.
-     * * Will *not* look at the scheme of this URI.
-     * * The result shall *not* be used for display purposes but for accessing a file on disk.
-     *
-     *
-     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
-     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
-     *
-     * ```ts
-        const u = URI.parse('file://server/c$/folder/file.txt')
-        u.authority === 'server'
-        u.path === '/shares/c$/file.txt'
-        u.fsPath === '\\server\c$\folder\file.txt'
-    ```
-     *
-     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
-     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
-     * with URIs that represent files on disk (`file` scheme).
-     */
-    get fsPath(): string;
-    with(change: {
-        scheme?: string;
-        authority?: string | null;
-        path?: string | null;
-        query?: string | null;
-        fragment?: string | null;
-    }): URI;
-    /**
-     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
-     * `file:///usr/home`, or `scheme:with/path`.
-     *
-     * @param value A string which represents an URI (see `URI#toString`).
-     */
-    static parse(value: string, _strict?: boolean): URI;
-    /**
-     * Creates a new URI from a file system path, e.g. `c:\my\files`,
-     * `/usr/home`, or `\\server\share\some\path`.
-     *
-     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
-     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
-     * `URI.parse('file://' + path)` because the path might contain characters that are
-     * interpreted (# and ?). See the following sample:
-     * ```ts
-    const good = URI.file('/coding/c#/project1');
-    good.scheme === 'file';
-    good.path === '/coding/c#/project1';
-    good.fragment === '';
-    const bad = URI.parse('file://' + '/coding/c#/project1');
-    bad.scheme === 'file';
-    bad.path === '/coding/c'; // path is now broken
-    bad.fragment === '/project1';
-    ```
-     *
-     * @param path A file system path (see `URI#fsPath`)
-     */
-    static file(path: string): URI;
-    static from(components: {
-        scheme: string;
-        authority?: string;
-        path?: string;
-        query?: string;
-        fragment?: string;
-    }): URI;
-    /**
-     * Join a URI path with path fragments and normalizes the resulting path.
-     *
-     * @param uri The input URI.
-     * @param pathFragment The path fragment to add to the URI path.
-     * @returns The resulting URI.
-     */
-    static joinPath(uri: URI, ...pathFragment: string[]): URI;
-    /**
-     * Creates a string representation for this URI. It's guaranteed that calling
-     * `URI.parse` with the result of this function creates an URI which is equal
-     * to this URI.
-     *
-     * * The result shall *not* be used for display purposes but for externalization or transport.
-     * * The result will be encoded using the percentage encoding and encoding happens mostly
-     * ignore the scheme-specific encoding rules.
-     *
-     * @param skipEncoding Do not encode the result, default is `false`
-     */
-    toString(skipEncoding?: boolean): string;
-    toJSON(): UriComponents;
-    static revive(data: UriComponents | URI): URI;
-    static revive(data: UriComponents | URI | undefined): URI | undefined;
-    static revive(data: UriComponents | URI | null): URI | null;
-    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
-}
-interface UriComponents {
-    scheme: string;
-    authority: string;
-    path: string;
-    query: string;
-    fragment: string;
-}
-
-/**
- * An interface for a JavaScript object that
- * acts a dictionary. The keys are strings.
- */
-type IStringDictionary<V> = Record<string, V>;
-
-type JSONSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'array' | 'object';
-interface IJSONSchema {
-    id?: string;
-    $id?: string;
-    $schema?: string;
-    type?: JSONSchemaType | JSONSchemaType[];
-    title?: string;
-    default?: any;
-    definitions?: IJSONSchemaMap;
-    description?: string;
-    properties?: IJSONSchemaMap;
-    patternProperties?: IJSONSchemaMap;
-    additionalProperties?: boolean | IJSONSchema;
-    minProperties?: number;
-    maxProperties?: number;
-    dependencies?: IJSONSchemaMap | {
-        [prop: string]: string[];
-    };
-    items?: IJSONSchema | IJSONSchema[];
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-    additionalItems?: boolean | IJSONSchema;
-    pattern?: string;
-    minLength?: number;
-    maxLength?: number;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: boolean | number;
-    exclusiveMaximum?: boolean | number;
-    multipleOf?: number;
-    required?: string[];
-    $ref?: string;
-    anyOf?: IJSONSchema[];
-    allOf?: IJSONSchema[];
-    oneOf?: IJSONSchema[];
-    not?: IJSONSchema;
-    enum?: any[];
-    format?: string;
-    const?: any;
-    contains?: IJSONSchema;
-    propertyNames?: IJSONSchema;
-    examples?: any[];
-    $comment?: string;
-    if?: IJSONSchema;
-    then?: IJSONSchema;
-    else?: IJSONSchema;
-    unevaluatedProperties?: boolean | IJSONSchema;
-    unevaluatedItems?: boolean | IJSONSchema;
-    minContains?: number;
-    maxContains?: number;
-    deprecated?: boolean;
-    dependentRequired?: {
-        [prop: string]: string[];
-    };
-    dependentSchemas?: IJSONSchemaMap;
-    $defs?: {
-        [name: string]: IJSONSchema;
-    };
-    $anchor?: string;
-    $recursiveRef?: string;
-    $recursiveAnchor?: string;
-    $vocabulary?: any;
-    prefixItems?: IJSONSchema[];
-    $dynamicRef?: string;
-    $dynamicAnchor?: string;
-    defaultSnippets?: IJSONSchemaSnippet[];
-    errorMessage?: string;
-    patternErrorMessage?: string;
-    deprecationMessage?: string;
-    markdownDeprecationMessage?: string;
-    enumDescriptions?: string[];
-    markdownEnumDescriptions?: string[];
-    markdownDescription?: string;
-    doNotSuggest?: boolean;
-    suggestSortText?: string;
-    allowComments?: boolean;
-    allowTrailingCommas?: boolean;
-}
-interface IJSONSchemaMap {
-    [name: string]: IJSONSchema;
-}
-interface IJSONSchemaSnippet {
-    label?: string;
-    description?: string;
-    body?: any;
-    bodyText?: string;
-}
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { I as IStringDictionary } from '../collections.js';
+import { E as Event } from '../event.js';
+import { I as IJSONSchema } from '../jsonSchema.js';
+export { a as IColorCustomizations, I as IThemeScopedColorCustomizations } from '../workbenchThemeService.js';
+export { b as IAnyWorkspaceIdentifier } from '../workspace.js';
+import { U as URI } from '../uri.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 type PolicyName = string;
 
@@ -790,45 +211,6 @@ type IConfigurationDefaultOverride = {
     readonly valuesSources?: Map<string, IExtensionInfo | string>;
 };
 
-interface IBaseWorkspaceIdentifier {
-    /**
-     * Every workspace (multi-root, single folder or empty)
-     * has a unique identifier. It is not possible to open
-     * a workspace with the same `id` in multiple windows
-     */
-    readonly id: string;
-}
-/**
- * A single folder workspace identifier is a path to a folder + id.
- */
-interface ISingleFolderWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
-    /**
-     * Folder path as `URI`.
-     */
-    readonly uri: URI;
-}
-/**
- * A multi-root workspace identifier is a path to a workspace file + id.
- */
-interface IWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
-    /**
-     * Workspace config file path as `URI`.
-     */
-    configPath: URI;
-}
-interface IEmptyWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
-}
-type IAnyWorkspaceIdentifier = IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IEmptyWorkspaceIdentifier;
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
-
-interface IThemeScopedColorCustomizations {
-    [colorId: string]: string;
-}
-interface IColorCustomizations {
-    [colorIdOrThemeScope: string]: IThemeScopedColorCustomizations | string;
-}
-
 interface IWorkspaceFolderCreationData {
     readonly uri: URI;
     readonly name?: string;
@@ -840,4 +222,4 @@ declare function onUserConfigurationChange(callback: () => void): vscode.Disposa
 declare const configurationRegistry: IConfigurationRegistry;
 declare function getServiceOverride(defaultWorkspaceUri: URI): IEditorOverrideServices;
 
-export { ConfigurationScope, IAnyWorkspaceIdentifier, IColorCustomizations, IConfigurationDefaults, IConfigurationNode, IThemeScopedColorCustomizations, IWorkspaceFolderCreationData, configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };
+export { ConfigurationScope, IConfigurationDefaults, IConfigurationNode, IWorkspaceFolderCreationData, configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };