naider 1.7.0

package/vscode-naide/node_modules/vscode-languageclient/lib/common/fileOperations.js

@@ -0,0 +1,333 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WillDeleteFilesFeature = exports.WillRenameFilesFeature = exports.WillCreateFilesFeature = exports.DidDeleteFilesFeature = exports.DidRenameFilesFeature = exports.DidCreateFilesFeature = void 0;
+const code = require("vscode");
+const minimatch = require("minimatch");
+const proto = require("vscode-languageserver-protocol");
+const UUID = require("./utils/uuid");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = {};
+    }
+    return target[key];
+}
+function access(target, key) {
+    return target[key];
+}
+function assign(target, key, value) {
+    target[key] = value;
+}
+class FileOperationFeature {
+    constructor(client, event, registrationType, clientCapability, serverCapability) {
+        this._client = client;
+        this._event = event;
+        this._registrationType = registrationType;
+        this._clientCapability = clientCapability;
+        this._serverCapability = serverCapability;
+        this._filters = new Map();
+    }
+    getState() {
+        return { kind: 'workspace', id: this._registrationType.method, registrations: this._filters.size > 0 };
+    }
+    filterSize() {
+        return this._filters.size;
+    }
+    get registrationType() {
+        return this._registrationType;
+    }
+    fillClientCapabilities(capabilities) {
+        const value = ensure(ensure(capabilities, 'workspace'), 'fileOperations');
+        // this happens n times but it is the same value so we tolerate this.
+        assign(value, 'dynamicRegistration', true);
+        assign(value, this._clientCapability, true);
+    }
+    initialize(capabilities) {
+        const options = capabilities.workspace?.fileOperations;
+        const capability = options !== undefined ? access(options, this._serverCapability) : undefined;
+        if (capability?.filters !== undefined) {
+            try {
+                this.register({
+                    id: UUID.generateUuid(),
+                    registerOptions: { filters: capability.filters }
+                });
+            }
+            catch (e) {
+                this._client.warn(`Ignoring invalid glob pattern for ${this._serverCapability} registration: ${e}`);
+            }
+        }
+    }
+    register(data) {
+        if (!this._listener) {
+            this._listener = this._event(this.send, this);
+        }
+        const minimatchFilter = data.registerOptions.filters.map((filter) => {
+            const matcher = new minimatch.Minimatch(filter.pattern.glob, FileOperationFeature.asMinimatchOptions(filter.pattern.options));
+            if (!matcher.makeRe()) {
+                throw new Error(`Invalid pattern ${filter.pattern.glob}!`);
+            }
+            return { scheme: filter.scheme, matcher, kind: filter.pattern.matches };
+        });
+        this._filters.set(data.id, minimatchFilter);
+    }
+    unregister(id) {
+        this._filters.delete(id);
+        if (this._filters.size === 0 && this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    clear() {
+        this._filters.clear();
+        if (this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    getFileType(uri) {
+        return FileOperationFeature.getFileType(uri);
+    }
+    async filter(event, prop) {
+        // (Asynchronously) map each file onto a boolean of whether it matches
+        // any of the globs.
+        const fileMatches = await Promise.all(event.files.map(async (item) => {
+            const uri = prop(item);
+            // Use fsPath to make this consistent with file system watchers but help
+            // minimatch to use '/' instead of `\\` if present.
+            const path = uri.fsPath.replace(/\\/g, '/');
+            for (const filters of this._filters.values()) {
+                for (const filter of filters) {
+                    if (filter.scheme !== undefined && filter.scheme !== uri.scheme) {
+                        continue;
+                    }
+                    if (filter.matcher.match(path)) {
+                        // The pattern matches. If kind is undefined then everything is ok
+                        if (filter.kind === undefined) {
+                            return true;
+                        }
+                        const fileType = await this.getFileType(uri);
+                        // If we can't determine the file type than we treat it as a match.
+                        // Dropping it would be another alternative.
+                        if (fileType === undefined) {
+                            this._client.error(`Failed to determine file type for ${uri.toString()}.`);
+                            return true;
+                        }
+                        if ((fileType === code.FileType.File && filter.kind === proto.FileOperationPatternKind.file) || (fileType === code.FileType.Directory && filter.kind === proto.FileOperationPatternKind.folder)) {
+                            return true;
+                        }
+                    }
+                    else if (filter.kind === proto.FileOperationPatternKind.folder) {
+                        const fileType = await FileOperationFeature.getFileType(uri);
+                        if (fileType === code.FileType.Directory && filter.matcher.match(`${path}/`)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }));
+        // Filter the files to those that matched.
+        const files = event.files.filter((_, index) => fileMatches[index]);
+        return { ...event, files };
+    }
+    static async getFileType(uri) {
+        try {
+            return (await code.workspace.fs.stat(uri)).type;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static asMinimatchOptions(options) {
+        // The spec doesn't state that dot files don't match. So we make
+        // matching those the default.
+        const result = { dot: true };
+        if (options?.ignoreCase === true) {
+            result.nocase = true;
+        }
+        return result;
+    }
+}
+class NotificationFileOperationFeature extends FileOperationFeature {
+    constructor(client, event, notificationType, clientCapability, serverCapability, accessUri, createParams) {
+        super(client, event, notificationType, clientCapability, serverCapability);
+        this._notificationType = notificationType;
+        this._accessUri = accessUri;
+        this._createParams = createParams;
+    }
+    async send(originalEvent) {
+        // Create a copy of the event that has the files filtered to match what the
+        // server wants.
+        const filteredEvent = await this.filter(originalEvent, this._accessUri);
+        if (filteredEvent.files.length) {
+            const next = async (event) => {
+                return this._client.sendNotification(this._notificationType, this._createParams(event));
+            };
+            return this.doSend(filteredEvent, next);
+        }
+    }
+}
+class CachingNotificationFileOperationFeature extends NotificationFileOperationFeature {
+    constructor() {
+        super(...arguments);
+        this._fsPathFileTypes = new Map();
+    }
+    async getFileType(uri) {
+        const fsPath = uri.fsPath;
+        if (this._fsPathFileTypes.has(fsPath)) {
+            return this._fsPathFileTypes.get(fsPath);
+        }
+        const type = await FileOperationFeature.getFileType(uri);
+        if (type) {
+            this._fsPathFileTypes.set(fsPath, type);
+        }
+        return type;
+    }
+    async cacheFileTypes(event, prop) {
+        // Calling filter will force the matching logic to run. For any item
+        // that requires a getFileType lookup, the overriden getFileType will
+        // be called that will cache the result so that when onDidRename fires,
+        // it can still be checked even though the item no longer exists on disk
+        // in its original location.
+        await this.filter(event, prop);
+    }
+    clearFileTypeCache() {
+        this._fsPathFileTypes.clear();
+    }
+    unregister(id) {
+        super.unregister(id);
+        if (this.filterSize() === 0 && this._willListener) {
+            this._willListener.dispose();
+            this._willListener = undefined;
+        }
+    }
+    clear() {
+        super.clear();
+        if (this._willListener) {
+            this._willListener.dispose();
+            this._willListener = undefined;
+        }
+    }
+}
+class DidCreateFilesFeature extends NotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidCreateFiles, proto.DidCreateFilesNotification.type, 'didCreate', 'didCreate', (i) => i, client.code2ProtocolConverter.asDidCreateFilesParams);
+    }
+    doSend(event, next) {
+        const middleware = this._client.middleware.workspace;
+        return middleware?.didCreateFiles
+            ? middleware.didCreateFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidCreateFilesFeature = DidCreateFilesFeature;
+class DidRenameFilesFeature extends CachingNotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidRenameFiles, proto.DidRenameFilesNotification.type, 'didRename', 'didRename', (i) => i.oldUri, client.code2ProtocolConverter.asDidRenameFilesParams);
+    }
+    register(data) {
+        if (!this._willListener) {
+            this._willListener = code.workspace.onWillRenameFiles(this.willRename, this);
+        }
+        super.register(data);
+    }
+    willRename(e) {
+        e.waitUntil(this.cacheFileTypes(e, (i) => i.oldUri));
+    }
+    doSend(event, next) {
+        this.clearFileTypeCache();
+        const middleware = this._client.middleware.workspace;
+        return middleware?.didRenameFiles
+            ? middleware.didRenameFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidRenameFilesFeature = DidRenameFilesFeature;
+class DidDeleteFilesFeature extends CachingNotificationFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onDidDeleteFiles, proto.DidDeleteFilesNotification.type, 'didDelete', 'didDelete', (i) => i, client.code2ProtocolConverter.asDidDeleteFilesParams);
+    }
+    register(data) {
+        if (!this._willListener) {
+            this._willListener = code.workspace.onWillDeleteFiles(this.willDelete, this);
+        }
+        super.register(data);
+    }
+    willDelete(e) {
+        e.waitUntil(this.cacheFileTypes(e, (i) => i));
+    }
+    doSend(event, next) {
+        this.clearFileTypeCache();
+        const middleware = this._client.middleware.workspace;
+        return middleware?.didDeleteFiles
+            ? middleware.didDeleteFiles(event, next)
+            : next(event);
+    }
+}
+exports.DidDeleteFilesFeature = DidDeleteFilesFeature;
+class RequestFileOperationFeature extends FileOperationFeature {
+    constructor(client, event, requestType, clientCapability, serverCapability, accessUri, createParams) {
+        super(client, event, requestType, clientCapability, serverCapability);
+        this._requestType = requestType;
+        this._accessUri = accessUri;
+        this._createParams = createParams;
+    }
+    async send(originalEvent) {
+        const waitUntil = this.waitUntil(originalEvent);
+        originalEvent.waitUntil(waitUntil);
+    }
+    async waitUntil(originalEvent) {
+        // Create a copy of the event that has the files filtered to match what the
+        // server wants.
+        const filteredEvent = await this.filter(originalEvent, this._accessUri);
+        if (filteredEvent.files.length) {
+            const next = (event) => {
+                return this._client.sendRequest(this._requestType, this._createParams(event), event.token)
+                    .then(this._client.protocol2CodeConverter.asWorkspaceEdit);
+            };
+            return this.doSend(filteredEvent, next);
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+class WillCreateFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillCreateFiles, proto.WillCreateFilesRequest.type, 'willCreate', 'willCreate', (i) => i, client.code2ProtocolConverter.asWillCreateFilesParams);
+    }
+    doSend(event, next) {
+        const middleware = this._client.middleware.workspace;
+        return middleware?.willCreateFiles
+            ? middleware.willCreateFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillCreateFilesFeature = WillCreateFilesFeature;
+class WillRenameFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillRenameFiles, proto.WillRenameFilesRequest.type, 'willRename', 'willRename', (i) => i.oldUri, client.code2ProtocolConverter.asWillRenameFilesParams);
+    }
+    doSend(event, next) {
+        const middleware = this._client.middleware.workspace;
+        return middleware?.willRenameFiles
+            ? middleware.willRenameFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillRenameFilesFeature = WillRenameFilesFeature;
+class WillDeleteFilesFeature extends RequestFileOperationFeature {
+    constructor(client) {
+        super(client, code.workspace.onWillDeleteFiles, proto.WillDeleteFilesRequest.type, 'willDelete', 'willDelete', (i) => i, client.code2ProtocolConverter.asWillDeleteFilesParams);
+    }
+    doSend(event, next) {
+        const middleware = this._client.middleware.workspace;
+        return middleware?.willDeleteFiles
+            ? middleware.willDeleteFiles(event, next)
+            : next(event);
+    }
+}
+exports.WillDeleteFilesFeature = WillDeleteFilesFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/fileSystemWatcher.d.ts

@@ -0,0 +1,18 @@
+import { FileSystemWatcher as VFileSystemWatcher } from 'vscode';
+import { ClientCapabilities, DidChangeWatchedFilesRegistrationOptions, DocumentSelector, FileEvent, RegistrationType, ServerCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, DynamicFeature, RegistrationData, FeatureState } from './features';
+export declare class FileSystemWatcherFeature implements DynamicFeature<DidChangeWatchedFilesRegistrationOptions> {
+    private readonly _client;
+    private readonly _notifyFileEvent;
+    private readonly _watchers;
+    constructor(client: FeatureClient<object>, notifyFileEvent: (event: FileEvent) => void);
+    getState(): FeatureState;
+    get registrationType(): RegistrationType<DidChangeWatchedFilesRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(_capabilities: ServerCapabilities, _documentSelector: DocumentSelector): void;
+    register(data: RegistrationData<DidChangeWatchedFilesRegistrationOptions>): void;
+    registerRaw(id: string, fileSystemWatchers: VFileSystemWatcher[]): void;
+    private hookListeners;
+    unregister(id: string): void;
+    clear(): void;
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/fileSystemWatcher.js

@@ -0,0 +1,95 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemWatcherFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class FileSystemWatcherFeature {
+    constructor(client, notifyFileEvent) {
+        this._client = client;
+        this._notifyFileEvent = notifyFileEvent;
+        this._watchers = new Map();
+    }
+    getState() {
+        return { kind: 'workspace', id: this.registrationType.method, registrations: this._watchers.size > 0 };
+    }
+    get registrationType() {
+        return vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type;
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'didChangeWatchedFiles').dynamicRegistration = true;
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'didChangeWatchedFiles').relativePatternSupport = true;
+    }
+    initialize(_capabilities, _documentSelector) {
+    }
+    register(data) {
+        if (!Array.isArray(data.registerOptions.watchers)) {
+            return;
+        }
+        const disposables = [];
+        for (const watcher of data.registerOptions.watchers) {
+            const globPattern = this._client.protocol2CodeConverter.asGlobPattern(watcher.globPattern);
+            if (globPattern === undefined) {
+                continue;
+            }
+            let watchCreate = true, watchChange = true, watchDelete = true;
+            if (watcher.kind !== undefined && watcher.kind !== null) {
+                watchCreate = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Create) !== 0;
+                watchChange = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Change) !== 0;
+                watchDelete = (watcher.kind & vscode_languageserver_protocol_1.WatchKind.Delete) !== 0;
+            }
+            const fileSystemWatcher = vscode_1.workspace.createFileSystemWatcher(globPattern, !watchCreate, !watchChange, !watchDelete);
+            this.hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, disposables);
+            disposables.push(fileSystemWatcher);
+        }
+        this._watchers.set(data.id, disposables);
+    }
+    registerRaw(id, fileSystemWatchers) {
+        let disposables = [];
+        for (let fileSystemWatcher of fileSystemWatchers) {
+            this.hookListeners(fileSystemWatcher, true, true, true, disposables);
+        }
+        this._watchers.set(id, disposables);
+    }
+    hookListeners(fileSystemWatcher, watchCreate, watchChange, watchDelete, listeners) {
+        if (watchCreate) {
+            fileSystemWatcher.onDidCreate((resource) => this._notifyFileEvent({
+                uri: this._client.code2ProtocolConverter.asUri(resource),
+                type: vscode_languageserver_protocol_1.FileChangeType.Created
+            }), null, listeners);
+        }
+        if (watchChange) {
+            fileSystemWatcher.onDidChange((resource) => this._notifyFileEvent({
+                uri: this._client.code2ProtocolConverter.asUri(resource),
+                type: vscode_languageserver_protocol_1.FileChangeType.Changed
+            }), null, listeners);
+        }
+        if (watchDelete) {
+            fileSystemWatcher.onDidDelete((resource) => this._notifyFileEvent({
+                uri: this._client.code2ProtocolConverter.asUri(resource),
+                type: vscode_languageserver_protocol_1.FileChangeType.Deleted
+            }), null, listeners);
+        }
+    }
+    unregister(id) {
+        let disposables = this._watchers.get(id);
+        if (disposables) {
+            for (let disposable of disposables) {
+                disposable.dispose();
+            }
+        }
+    }
+    clear() {
+        this._watchers.forEach((disposables) => {
+            for (let disposable of disposables) {
+                disposable.dispose();
+            }
+        });
+        this._watchers.clear();
+    }
+}
+exports.FileSystemWatcherFeature = FileSystemWatcherFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/foldingRange.d.ts

@@ -0,0 +1,19 @@
+import { Disposable, TextDocument, ProviderResult, FoldingRange as VFoldingRange, FoldingContext, FoldingRangeProvider, EventEmitter } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, FoldingRangeRegistrationOptions, FoldingRangeOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export interface ProvideFoldingRangeSignature {
+    (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken): ProviderResult<VFoldingRange[]>;
+}
+export interface FoldingRangeProviderMiddleware {
+    provideFoldingRanges?: (this: void, document: TextDocument, context: FoldingContext, token: CancellationToken, next: ProvideFoldingRangeSignature) => ProviderResult<VFoldingRange[]>;
+}
+export type FoldingRangeProviderShape = {
+    provider: FoldingRangeProvider;
+    onDidChangeFoldingRange: EventEmitter<void>;
+};
+export declare class FoldingRangeFeature extends TextDocumentLanguageFeature<boolean | FoldingRangeOptions, FoldingRangeRegistrationOptions, FoldingRangeProviderShape, FoldingRangeProviderMiddleware> {
+    constructor(client: FeatureClient<FoldingRangeProviderMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: FoldingRangeRegistrationOptions): [Disposable, FoldingRangeProviderShape];
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/foldingRange.js

@@ -0,0 +1,65 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoldingRangeFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class FoldingRangeFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.FoldingRangeRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'foldingRange');
+        capability.dynamicRegistration = true;
+        capability.rangeLimit = 5000;
+        capability.lineFoldingOnly = true;
+        capability.foldingRangeKind = { valueSet: [vscode_languageserver_protocol_1.FoldingRangeKind.Comment, vscode_languageserver_protocol_1.FoldingRangeKind.Imports, vscode_languageserver_protocol_1.FoldingRangeKind.Region] };
+        capability.foldingRange = { collapsedText: false };
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'foldingRange').refreshSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        this._client.onRequest(vscode_languageserver_protocol_1.FoldingRangeRefreshRequest.type, async () => {
+            for (const provider of this.getAllProviders()) {
+                provider.onDidChangeFoldingRange.fire();
+            }
+        });
+        let [id, options] = this.getRegistration(documentSelector, capabilities.foldingRangeProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const eventEmitter = new vscode_1.EventEmitter();
+        const provider = {
+            onDidChangeFoldingRanges: eventEmitter.event,
+            provideFoldingRanges: (document, context, token) => {
+                const client = this._client;
+                const provideFoldingRanges = (document, _, token) => {
+                    const requestParams = {
+                        textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                    };
+                    return client.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, requestParams, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asFoldingRanges(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideFoldingRanges
+                    ? middleware.provideFoldingRanges(document, context, token, provideFoldingRanges)
+                    : provideFoldingRanges(document, context, token);
+            }
+        };
+        return [vscode_1.languages.registerFoldingRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), { provider: provider, onDidChangeFoldingRange: eventEmitter }];
+    }
+}
+exports.FoldingRangeFeature = FoldingRangeFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/formatting.d.ts

@@ -0,0 +1,39 @@
+import { Disposable, TextDocument, ProviderResult, Range as VRange, Position as VPosition, TextEdit as VTextEdit, FormattingOptions as VFormattingOptions, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider, OnTypeFormattingEditProvider } from 'vscode';
+import { ClientCapabilities, CancellationToken, ServerCapabilities, DocumentSelector, DocumentHighlightRegistrationOptions, DocumentFormattingOptions, TextDocumentRegistrationOptions, DocumentRangeFormattingRegistrationOptions, DocumentRangeFormattingOptions, DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingRegistrationOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export interface ProvideDocumentFormattingEditsSignature {
+    (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideDocumentRangeFormattingEditsSignature {
+    (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideDocumentRangesFormattingEditsSignature {
+    (this: void, document: TextDocument, ranges: VRange[], options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface ProvideOnTypeFormattingEditsSignature {
+    (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken): ProviderResult<VTextEdit[]>;
+}
+export interface FormattingMiddleware {
+    provideDocumentFormattingEdits?: (this: void, document: TextDocument, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideDocumentRangeFormattingEdits?: (this: void, document: TextDocument, range: VRange, options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentRangeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideDocumentRangesFormattingEdits?: (this: void, document: TextDocument, range: VRange[], options: VFormattingOptions, token: CancellationToken, next: ProvideDocumentRangesFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+    provideOnTypeFormattingEdits?: (this: void, document: TextDocument, position: VPosition, ch: string, options: VFormattingOptions, token: CancellationToken, next: ProvideOnTypeFormattingEditsSignature) => ProviderResult<VTextEdit[]>;
+}
+export declare class DocumentFormattingFeature extends TextDocumentLanguageFeature<boolean | DocumentFormattingOptions, DocumentHighlightRegistrationOptions, DocumentFormattingEditProvider, FormattingMiddleware> {
+    constructor(client: FeatureClient<FormattingMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: TextDocumentRegistrationOptions): [Disposable, DocumentFormattingEditProvider];
+}
+export declare class DocumentRangeFormattingFeature extends TextDocumentLanguageFeature<boolean | DocumentRangeFormattingOptions, DocumentRangeFormattingRegistrationOptions, DocumentRangeFormattingEditProvider, FormattingMiddleware> {
+    constructor(client: FeatureClient<FormattingMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DocumentRangeFormattingRegistrationOptions): [Disposable, DocumentRangeFormattingEditProvider];
+}
+export declare class DocumentOnTypeFormattingFeature extends TextDocumentLanguageFeature<DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingRegistrationOptions, OnTypeFormattingEditProvider, FormattingMiddleware> {
+    constructor(client: FeatureClient<FormattingMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DocumentOnTypeFormattingRegistrationOptions): [Disposable, OnTypeFormattingEditProvider];
+}