@difizen/mana-core/lib/keybinding/vs/configuration/configurationModels.d.ts

import { Emitter } from '@difizen/mana-common';
import type { URI } from '@difizen/mana-common';
import type { Event } from '@difizen/mana-common';
import { ResourceMap, VSDisposable } from '../../../utils';
import type { IOverrides, IConfigurationModel, IConfigurationOverrides, IConfigurationData, IConfigurationValue, ConfigurationTarget, IConfigurationChangeEvent, IConfigurationChange } from './configuration';
import { ConfigurationScope } from './configurationRegistry';
interface Workspace {
    getFolder: (_resource: URI) => {
        uri: URI;
    } | null;
}
export declare function distinct<T>(array: readonly T[], keyFn?: (_t: T) => string): T[];
export declare function equals<T>(one: readonly T[] | undefined, other: readonly T[] | undefined, itemEquals?: (_a: T, _b: T) => boolean): boolean;
export declare class ConfigurationModel implements IConfigurationModel {
    private isFrozen;
    private _contents;
    private _keys;
    private _overrides;
    constructor(_contents?: any, _keys?: string[], _overrides?: IOverrides[]);
    get contents(): any;
    get overrides(): IOverrides[];
    get keys(): string[];
    isEmpty(): boolean;
    getValue<V>(section: string | undefined): V;
    getOverrideValue<V>(section: string | undefined, overrideIdentifier: string): V | undefined;
    getKeysForOverrideIdentifier(identifier: string): string[];
    override(identifier: string): ConfigurationModel;
    merge(...others: ConfigurationModel[]): ConfigurationModel;
    freeze(): ConfigurationModel;
    private mergeContents;
    private checkAndFreeze;
    private getContentsForOverrideIdentifer;
    toJSON(): IConfigurationModel;
    setValue(key: string, value: any): void;
    removeValue(key: string): void;
    private addKey;
    private removeKey;
}
export declare class DefaultConfigurationModel extends ConfigurationModel {
    constructor();
}
export declare class ConfigurationModelParser {
    private _raw;
    private _configurationModel;
    private _parseErrors;
    protected readonly _name: string;
    private _scopes?;
    constructor(_name: string, _scopes?: ConfigurationScope[]);
    get configurationModel(): ConfigurationModel;
    get errors(): any[];
    parseContent(content: string | null | undefined): void;
    parseRaw(raw: any): void;
    parse(): void;
    protected doParseContent(content: string): any;
    protected doParseRaw(raw: any): IConfigurationModel;
    private filterByScope;
    private getScope;
}
export declare class UserSettings extends VSDisposable {
    private readonly parser;
    protected readonly _onDidChange: Emitter<void>;
    readonly onDidChange: Event<void>;
    private readonly scopes;
    constructor(scopes: ConfigurationScope[] | undefined);
    loadConfiguration(): Promise<ConfigurationModel>;
    reprocess(): ConfigurationModel;
}
export declare class Configuration {
    private _workspaceConsolidatedConfiguration;
    private _foldersConsolidatedConfigurations;
    private _defaultConfiguration;
    private _localUserConfiguration;
    private _remoteUserConfiguration;
    private _workspaceConfiguration;
    private _memoryConfiguration;
    private _memoryConfigurationByResource;
    private _freeze;
    constructor(_defaultConfiguration: ConfigurationModel, _localUserConfiguration: ConfigurationModel, _remoteUserConfiguration?: ConfigurationModel, _workspaceConfiguration?: ConfigurationModel, _memoryConfiguration?: ConfigurationModel, _memoryConfigurationByResource?: ResourceMap<ConfigurationModel>, _freeze?: boolean);
    getValue(section: string | undefined, overrides: IConfigurationOverrides, workspace: Workspace | undefined): any;
    updateValue(_key: string, _value: any, _overrides?: IConfigurationOverrides): void;
    inspect<C>(key: string, overrides: IConfigurationOverrides, _workspace: Workspace | undefined): IConfigurationValue<C>;
    keys(_workspace: Workspace | undefined): {
        default: string[];
        user: string[];
        workspace: string[];
        workspaceFolder: string[];
    };
    updateDefaultConfiguration(defaultConfiguration: ConfigurationModel): void;
    updateLocalUserConfiguration(localUserConfiguration: ConfigurationModel): void;
    updateRemoteUserConfiguration(remoteUserConfiguration: ConfigurationModel): void;
    updateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel): void;
    compareAndUpdateDefaultConfiguration(defaults: ConfigurationModel, keys: string[]): IConfigurationChange;
    compareAndUpdateLocalUserConfiguration(user: ConfigurationModel): IConfigurationChange;
    compareAndUpdateRemoteUserConfiguration(user: ConfigurationModel): IConfigurationChange;
    compareAndUpdateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel): IConfigurationChange;
    compareAndUpdateFolderConfiguration(_resource: URI, _folderConfiguration: ConfigurationModel): IConfigurationChange;
    compareAndDeleteFolderConfiguration(_folder: URI): IConfigurationChange;
    get defaults(): ConfigurationModel;
    private _userConfiguration;
    get userConfiguration(): ConfigurationModel;
    get localUserConfiguration(): ConfigurationModel;
    get remoteUserConfiguration(): ConfigurationModel;
    get workspaceConfiguration(): ConfigurationModel;
    private getConsolidateConfigurationModel;
    private getConsolidatedConfigurationModelForResource;
    private getWorkspaceConsolidatedConfiguration;
    toData(): IConfigurationData;
    allKeys(): string[];
    protected getAllKeysForOverrideIdentifier(overrideIdentifier: string): string[];
    static parse(data: IConfigurationData): Configuration;
    private static parseConfigurationModel;
}
export declare function mergeChanges(...changes: IConfigurationChange[]): IConfigurationChange;
export declare class ConfigurationChangeEvent implements IConfigurationChangeEvent {
    private readonly affectedKeysTree;
    readonly affectedKeys: string[];
    source: ConfigurationTarget;
    sourceConfig: any;
    readonly change: IConfigurationChange;
    private readonly previous;
    private readonly currentConfiguraiton;
    private readonly currentWorkspace?;
    constructor(change: IConfigurationChange, previous: {
        workspace?: Workspace;
        data: IConfigurationData;
    } | undefined, currentConfiguraiton: Configuration, currentWorkspace?: Workspace);
    private _previousConfiguration;
    get previousConfiguration(): Configuration | undefined;
    affectsConfiguration(section: string, overrides?: IConfigurationOverrides): boolean;
    private doesAffectedKeysTreeContains;
}
export declare class AllKeysConfigurationChangeEvent extends ConfigurationChangeEvent {
    source: ConfigurationTarget;
    sourceConfig: any;
    constructor(configuration: Configuration, workspace: Workspace, source: ConfigurationTarget, sourceConfig: any);
}
export {};
//# sourceMappingURL=configurationModels.d.ts.map