@codingame/monaco-vscode-api 1.76.9 → 1.78.0-next.0

package/dist/monaco.d.ts

@@ -64,6 +64,9 @@ declare abstract class Disposable implements IDisposable {
      */
     protected _register<T extends IDisposable>(o: T): T;
 }
+interface IReference<T> extends IDisposable {
+    readonly object: T;
+}
 
 /**
  * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
@@ -337,15 +340,28 @@ declare namespace Event {
      */
     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>;
@@ -355,8 +371,7 @@ declare namespace Event {
      */
     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.
+     * 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>;
@@ -395,9 +410,22 @@ declare namespace 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>;
     /**
@@ -419,9 +447,24 @@ declare namespace Event {
      */
     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 {
@@ -437,19 +480,59 @@ declare namespace Event {
         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>;
 }
@@ -776,16 +859,16 @@ interface IContextKeyChangeEvent {
     affectsSome(keys: IReadableSet<string>): boolean;
     allKeysContainedIn(keys: IReadableSet<string>): boolean;
 }
+type IScopedContextKeyService = IContextKeyService & IDisposable;
 declare const IContextKeyService: ServiceIdentifier<IContextKeyService>;
 interface IContextKeyService {
     readonly _serviceBrand: undefined;
-    dispose(): void;
     onDidChangeContext: Event<IContextKeyChangeEvent>;
     bufferChangeEvents(callback: Function): void;
     createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): IContextKey<T>;
     contextMatchesRules(rules: ContextKeyExpression | undefined): boolean;
     getContextKeyValue<T>(key: string): T | undefined;
-    createScoped(target: IContextKeyServiceTarget): IContextKeyService;
+    createScoped(target: IContextKeyServiceTarget): IScopedContextKeyService;
     createOverlay(overlay: Iterable<[string, any]>): IContextKeyService;
     getContext(target: IContextKeyServiceTarget | null): IContext;
     updateParent(parentContextKeyService: IContextKeyService): void;
@@ -1308,6 +1391,54 @@ declare class Selection extends Range {
     static createWithDirection(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, direction: SelectionDirection): Selection;
 }
 
+declare class TextChange {
+    readonly oldPosition: number;
+    readonly oldText: string;
+    readonly newPosition: number;
+    readonly newText: string;
+    get oldLength(): number;
+    get oldEnd(): number;
+    get newLength(): number;
+    get newEnd(): number;
+    constructor(oldPosition: number, oldText: string, newPosition: number, newText: string);
+    toString(): string;
+    private static _writeStringSize;
+    private static _writeString;
+    private static _readString;
+    writeSize(): number;
+    write(b: Uint8Array, offset: number): number;
+    static read(b: Uint8Array, offset: number, dest: TextChange[]): number;
+}
+
+/**
+ * A fast character classifier that uses a compact array for ASCII values.
+ */
+declare class CharacterClassifier<T extends number> {
+    /**
+     * Maintain a compact (fully initialized ASCII map for quickly classifying ASCII characters - used more often in code).
+     */
+    protected readonly _asciiMap: Uint8Array;
+    /**
+     * The entire map (sparse array).
+     */
+    protected readonly _map: Map<number, number>;
+    protected readonly _defaultValue: number;
+    constructor(_defaultValue: T);
+    private static _createAsciiMap;
+    set(charCode: number, _value: T): void;
+    get(charCode: number): T;
+    clear(): void;
+}
+
+declare const enum WordCharacterClass {
+    Regular = 0,
+    Whitespace = 1,
+    WordSeparator = 2
+}
+declare class WordCharacterClassifier extends CharacterClassifier<WordCharacterClass> {
+    constructor(wordSeparators: string);
+}
+
 interface ThemeColor {
     id: string;
 }
@@ -2469,6 +2600,10 @@ interface FormattingOptions {
      * Prefer spaces over tabs.
      */
     insertSpaces: boolean;
+    /**
+     * The list of multiple ranges to format at once, if the provider supports it.
+     */
+    ranges?: Range[];
 }
 /**
  * The document formatting provider interface defines the contract between extensions and
@@ -2503,6 +2638,7 @@ interface DocumentRangeFormattingEditProvider {
      * of the range to full syntax nodes.
      */
     provideDocumentRangeFormattingEdits(model: ITextModel, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
+    provideDocumentRangesFormattingEdits?(model: ITextModel, ranges: Range[], options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
 }
 /**
  * The document formatting provider interface defines the contract between extensions and
@@ -3407,6 +3543,25 @@ declare class ResolvedLanguageConfiguration {
     private static _handleComments;
 }
 
+interface IModelContentChange {
+    /**
+     * The range that got replaced.
+     */
+    readonly range: IRange;
+    /**
+     * The offset of the range that got replaced.
+     */
+    readonly rangeOffset: number;
+    /**
+     * The length of the range that got replaced.
+     */
+    readonly rangeLength: number;
+    /**
+     * The new text for the range.
+     */
+    readonly text: string;
+}
+
 /**
  * Vertical Lane in the overview ruler of the editor.
  */
@@ -3477,6 +3632,8 @@ interface IModelDecorationOptions {
      * In this case, the range must be empty and set to the last line.
      */
     blockIsAfterEnd?: boolean | null;
+    blockDoesNotCollapse?: boolean | null;
+    blockPadding?: [top: number, right: number, bottom: number, left: number] | null;
     /**
      * Message to be rendered when hovering over the glyph margin decoration.
      */
@@ -3651,6 +3808,36 @@ interface IModelDecorationsChangeAccessor {
      */
     deltaDecorations(oldDecorations: string[], newDecorations: IModelDeltaDecoration[]): string[];
 }
+/**
+ * End of line character preference.
+ */
+declare const enum EndOfLinePreference {
+    /**
+     * Use the end of line character identified in the text buffer.
+     */
+    TextDefined = 0,
+    /**
+     * Use line feed (\n) as the end of line character.
+     */
+    LF = 1,
+    /**
+     * Use carriage return and line feed (\r\n) as the end of line character.
+     */
+    CRLF = 2
+}
+/**
+ * The default end of line to use when instantiating models.
+ */
+declare const enum DefaultEndOfLine {
+    /**
+     * Use line feed (\n) as the end of line character.
+     */
+    LF = 1,
+    /**
+     * Use carriage return and line feed (\r\n) as the end of line character.
+     */
+    CRLF = 2
+}
 /**
  * End of line character preference.
  */
@@ -3664,6 +3851,69 @@ declare const enum EndOfLineSequence {
      */
     CRLF = 1
 }
+/**
+ * An identifier for a single edit operation.
+ * @internal
+ */
+interface ISingleEditOperationIdentifier {
+    /**
+     * Identifier major
+     */
+    major: number;
+    /**
+     * Identifier minor
+     */
+    minor: number;
+}
+/**
+ * A single edit operation, that has an identifier.
+ */
+interface IIdentifiedSingleEditOperation extends ISingleEditOperation {
+    /**
+     * An identifier associated with this single edit operation.
+     * @internal
+     */
+    identifier?: ISingleEditOperationIdentifier | null;
+    /**
+     * This indicates that this operation is inserting automatic whitespace
+     * that can be removed on next model edit operation if `config.trimAutoWhitespace` is true.
+     * @internal
+     */
+    isAutoWhitespaceEdit?: boolean;
+    /**
+     * This indicates that this operation is in a set of operations that are tracked and should not be "simplified".
+     * @internal
+     */
+    _isTracked?: boolean;
+}
+interface IValidEditOperation {
+    /**
+     * An identifier associated with this single edit operation.
+     * @internal
+     */
+    identifier: ISingleEditOperationIdentifier | null;
+    /**
+     * The range to replace. This can be empty to emulate a simple insert.
+     */
+    range: Range;
+    /**
+     * The text to replace with. This can be empty to emulate a simple delete.
+     */
+    text: string;
+    /**
+     * @internal
+     */
+    textChange: TextChange;
+}
+declare class FindMatch {
+    _findMatchBrand: void;
+    readonly range: Range;
+    readonly matches: string[] | null;
+    /**
+     * @internal
+     */
+    constructor(range: Range, matches: string[] | null);
+}
 /**
  * Describes the behavior of decorations when typing/editing near their edges.
  * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`
@@ -3674,10 +3924,113 @@ declare const enum TrackedRangeStickiness {
     GrowsOnlyWhenTypingBefore = 2,
     GrowsOnlyWhenTypingAfter = 3
 }
+/**
+ * Text snapshot that works like an iterator.
+ * Will try to return chunks of roughly ~64KB size.
+ * Will return null when finished.
+ */
+interface ITextSnapshot {
+    read(): string | null;
+}
 /**
  * A model.
  */
 type ITextModel = monaco.editor.ITextModel
+/**
+ * @internal
+ */
+interface ITextBufferFactory {
+    create(defaultEOL: DefaultEndOfLine): {
+        textBuffer: ITextBuffer;
+        disposable: IDisposable;
+    };
+    getFirstLineText(lengthLimit: number): string;
+}
+/**
+ * @internal
+ */
+declare class ValidAnnotatedEditOperation implements IIdentifiedSingleEditOperation {
+    readonly identifier: ISingleEditOperationIdentifier | null;
+    readonly range: Range;
+    readonly text: string | null;
+    readonly forceMoveMarkers: boolean;
+    readonly isAutoWhitespaceEdit: boolean;
+    readonly _isTracked: boolean;
+    constructor(identifier: ISingleEditOperationIdentifier | null, range: Range, text: string | null, forceMoveMarkers: boolean, isAutoWhitespaceEdit: boolean, _isTracked: boolean);
+}
+/**
+ * @internal
+ *
+ * `lineNumber` is 1 based.
+ */
+interface IReadonlyTextBuffer {
+    onDidChangeContent: Event<void>;
+    equals(other: ITextBuffer): boolean;
+    mightContainRTL(): boolean;
+    mightContainUnusualLineTerminators(): boolean;
+    resetMightContainUnusualLineTerminators(): void;
+    mightContainNonBasicASCII(): boolean;
+    getBOM(): string;
+    getEOL(): string;
+    getOffsetAt(lineNumber: number, column: number): number;
+    getPositionAt(offset: number): Position;
+    getRangeAt(offset: number, length: number): Range;
+    getValueInRange(range: Range, eol: EndOfLinePreference): string;
+    createSnapshot(preserveBOM: boolean): ITextSnapshot;
+    getValueLengthInRange(range: Range, eol: EndOfLinePreference): number;
+    getCharacterCountInRange(range: Range, eol: EndOfLinePreference): number;
+    getLength(): number;
+    getLineCount(): number;
+    getLinesContent(): string[];
+    getLineContent(lineNumber: number): string;
+    getLineCharCode(lineNumber: number, index: number): number;
+    getCharCode(offset: number): number;
+    getLineLength(lineNumber: number): number;
+    getLineFirstNonWhitespaceColumn(lineNumber: number): number;
+    getLineLastNonWhitespaceColumn(lineNumber: number): number;
+    findMatchesLineByLine(searchRange: Range, searchData: SearchData, captureMatches: boolean, limitResultCount: number): FindMatch[];
+}
+/**
+ * @internal
+ */
+declare class SearchData {
+    /**
+     * The regex to search for. Always defined.
+     */
+    readonly regex: RegExp;
+    /**
+     * The word separator classifier.
+     */
+    readonly wordSeparators: WordCharacterClassifier | null;
+    /**
+     * The simple string to search for (if possible).
+     */
+    readonly simpleSearch: string | null;
+    constructor(regex: RegExp, wordSeparators: WordCharacterClassifier | null, simpleSearch: string | null);
+}
+/**
+ * @internal
+ */
+interface ITextBuffer extends IReadonlyTextBuffer {
+    setEOL(newEOL: '\r\n' | '\n'): void;
+    applyEdits(rawOperations: ValidAnnotatedEditOperation[], recordTrimAutoWhitespace: boolean, computeUndoEdits: boolean): ApplyEditsResult;
+}
+/**
+ * @internal
+ */
+declare class ApplyEditsResult {
+    readonly reverseEdits: IValidEditOperation[] | null;
+    readonly changes: IInternalModelContentChange[];
+    readonly trimAutoWhitespaceLineNumbers: number[] | null;
+    constructor(reverseEdits: IValidEditOperation[] | null, changes: IInternalModelContentChange[], trimAutoWhitespaceLineNumbers: number[] | null);
+}
+/**
+ * @internal
+ */
+interface IInternalModelContentChange extends IModelContentChange {
+    range: Range;
+    forceMoveMarkers: boolean;
+}
 
 /**
  * Configuration options for auto indentation in the editor
@@ -3766,6 +4119,29 @@ declare function registerColor(id: string, defaults: ColorDefaults | null, descr
  */
 type ICodeEditor = monaco.editor.ICodeEditor
 
+interface IEditorModel {
+    /**
+     * Emitted when the model is about to be disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Resolves the model.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Find out if the editor model was resolved or not.
+     */
+    isResolved(): boolean;
+    /**
+     * Find out if this model has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Dispose associated resources
+     */
+    dispose(): void;
+}
+
 interface IAction {
     readonly id: string;
     label: string;
@@ -3773,7 +4149,7 @@ interface IAction {
     class: string | undefined;
     enabled: boolean;
     checked?: boolean;
-    run(event?: unknown): unknown;
+    run(...args: unknown[]): unknown;
 }
 
 type TypeConstraint = string | Function;
@@ -3810,18 +4186,33 @@ declare const CommandsRegistry: ICommandRegistry;
 
 type Severity = Severity$1;
 type NotificationMessage = string | Error;
+declare enum NotificationPriority {
+    /**
+     * Default priority: notification will be visible unless do not disturb mode is enabled.
+     */
+    DEFAULT = 0,
+    /**
+     * Silent priority: notification will only be visible from the notifications center.
+     */
+    SILENT = 1,
+    /**
+     * Urgent priority: notification will be visible even when do not disturb mode is enabled.
+     */
+    URGENT = 2
+}
 interface INotificationProperties {
     /**
-     * Sticky notifications are not automatically removed after a certain timeout. By
-     * default, notifications with primary actions and severity error are always sticky.
+     * Sticky notifications are not automatically removed after a certain timeout.
+     *
+     * Currently, only 2 kinds of notifications are sticky:
+     * - Error notifications with primary actions
+     * - Notifications that show progress
      */
     readonly sticky?: boolean;
     /**
-     * Silent notifications are not shown to the user unless the notification center
-     * is opened. The status bar will still indicate all number of notifications to
-     * catch some attention.
+     * Allows to override the priority of the notification based on needs.
      */
-    readonly silent?: boolean;
+    readonly priority?: NotificationPriority;
     /**
      * Adds an action to never show the notification again. The choice will be persisted
      * such as future requests will not cause the notification to show again.
@@ -4509,14 +4900,595 @@ interface IJSONContributionRegistry {
     getSchemaContributions(): ISchemaContributions;
 }
 
+interface ReadableStreamEvents<T> {
+    /**
+     * The 'data' event is emitted whenever the stream is
+     * relinquishing ownership of a chunk of data to a consumer.
+     *
+     * NOTE: PLEASE UNDERSTAND THAT ADDING A DATA LISTENER CAN
+     * TURN THE STREAM INTO FLOWING MODE. IT IS THEREFOR THE
+     * LAST LISTENER THAT SHOULD BE ADDED AND NOT THE FIRST
+     *
+     * Use `listenStream` as a helper method to listen to
+     * stream events in the right order.
+     */
+    on(event: 'data', callback: (data: T) => void): void;
+    /**
+     * Emitted when any error occurs.
+     */
+    on(event: 'error', callback: (err: Error) => void): void;
+    /**
+     * The 'end' event is emitted when there is no more data
+     * to be consumed from the stream. The 'end' event will
+     * not be emitted unless the data is completely consumed.
+     */
+    on(event: 'end', callback: () => void): void;
+}
+/**
+ * A interface that emulates the API shape of a node.js readable
+ * stream for use in native and web environments.
+ */
+interface ReadableStream<T> extends ReadableStreamEvents<T> {
+    /**
+     * Stops emitting any events until resume() is called.
+     */
+    pause(): void;
+    /**
+     * Starts emitting events again after pause() was called.
+     */
+    resume(): void;
+    /**
+     * Destroys the stream and stops emitting any event.
+     */
+    destroy(): void;
+    /**
+     * Allows to remove a listener that was previously added.
+     */
+    removeListener(event: string, callback: Function): void;
+}
+/**
+ * A interface that emulates the API shape of a node.js readable
+ * for use in native and web environments.
+ */
+interface Readable<T> {
+    /**
+     * Read data from the underlying source. Will return
+     * null to indicate that no more data can be read.
+     */
+    read(): T | null;
+}
+
+declare class VSBuffer {
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static alloc(byteLength: number): VSBuffer;
+    /**
+     * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for
+     * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,
+     * which is not transferrable.
+     */
+    static wrap(actual: Uint8Array): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static fromString(source: string, options?: {
+        dontUseNodeBuffer?: boolean;
+    }): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static fromByteArray(source: number[]): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer;
+    readonly buffer: Uint8Array;
+    readonly byteLength: number;
+    private constructor();
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    clone(): VSBuffer;
+    toString(): string;
+    slice(start?: number, end?: number): VSBuffer;
+    set(array: VSBuffer, offset?: number): void;
+    set(array: Uint8Array, offset?: number): void;
+    set(array: ArrayBuffer, offset?: number): void;
+    set(array: ArrayBufferView, offset?: number): void;
+    set(array: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView, offset?: number): void;
+    readUInt32BE(offset: number): number;
+    writeUInt32BE(value: number, offset: number): void;
+    readUInt32LE(offset: number): number;
+    writeUInt32LE(value: number, offset: number): void;
+    readUInt8(offset: number): number;
+    writeUInt8(value: number, offset: number): void;
+}
+interface VSBufferReadable extends Readable<VSBuffer> {
+}
+interface VSBufferReadableStream extends ReadableStream<VSBuffer> {
+}
+
+interface IFileReadLimits {
+    /**
+     * If the file exceeds the given size, an error of kind
+     * `FILE_TOO_LARGE` will be thrown.
+     */
+    size?: number;
+    /**
+     * If the file exceeds the given size, an error of kind
+     * `FILE_EXCEEDS_MEMORY_LIMIT` will be thrown.
+     */
+    memory?: number;
+}
+interface IFileDeleteOptions {
+    /**
+     * Set to `true` to recursively delete any children of the file. This
+     * only applies to folders and can lead to an error unless provided
+     * if the folder is not empty.
+     */
+    readonly recursive: boolean;
+    /**
+     * Set to `true` to attempt to move the file to trash
+     * instead of deleting it permanently from disk. This
+     * option maybe not be supported on all providers.
+     */
+    readonly useTrash: boolean;
+}
+interface IBaseFileStat {
+    /**
+     * The unified resource identifier of this file or folder.
+     */
+    readonly resource: URI;
+    /**
+     * The name which is the last segment
+     * of the {{path}}.
+     */
+    readonly name: string;
+    /**
+     * The size of the file.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly size?: number;
+    /**
+     * The last modification date represented as millis from unix epoch.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly mtime?: number;
+    /**
+     * The creation date represented as millis from unix epoch.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly ctime?: number;
+    /**
+     * A unique identifier that represents the
+     * current state of the file or directory.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly etag?: string;
+    /**
+     * The file is read-only.
+     */
+    readonly readonly?: boolean;
+}
+interface IBaseFileStatWithMetadata extends Required<IBaseFileStat> {
+}
+/**
+ * A file resource with meta information and resolved children if any.
+ */
+interface IFileStat extends IBaseFileStat {
+    /**
+     * The resource is a file.
+     */
+    readonly isFile: boolean;
+    /**
+     * The resource is a directory.
+     */
+    readonly isDirectory: boolean;
+    /**
+     * The resource is a symbolic link. Note: even when the
+     * file is a symbolic link, you can test for `FileType.File`
+     * and `FileType.Directory` to know the type of the target
+     * the link points to.
+     */
+    readonly isSymbolicLink: boolean;
+    /**
+     * The children of the file stat or undefined if none.
+     */
+    children: IFileStat[] | undefined;
+}
+interface IFileStatWithMetadata extends IFileStat, IBaseFileStatWithMetadata {
+    readonly mtime: number;
+    readonly ctime: number;
+    readonly etag: string;
+    readonly size: number;
+    readonly readonly: boolean;
+    readonly children: IFileStatWithMetadata[] | undefined;
+}
+
+interface ITextEditorModel extends IEditorModel {
+    /**
+     * Provides access to the underlying `ITextModel`.
+     */
+    readonly textEditorModel: ITextModel | null;
+    /**
+     * Creates a snapshot of the model's contents.
+     */
+    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
+    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
+    /**
+     * Signals if this model is readonly or not.
+     */
+    isReadonly(): boolean;
+    /**
+     * The language id of the text model if known.
+     */
+    getLanguageId(): string | undefined;
+}
+interface IResolvedTextEditorModel extends ITextEditorModel {
+    /**
+     * Same as ITextEditorModel#textEditorModel, but never null.
+     */
+    readonly textEditorModel: ITextModel;
+}
+
+declare const enum SaveReason {
+    /**
+     * Explicit user gesture.
+     */
+    EXPLICIT = 1,
+    /**
+     * Auto save after a timeout.
+     */
+    AUTO = 2,
+    /**
+     * Auto save after editor focus change.
+     */
+    FOCUS_CHANGE = 3,
+    /**
+     * Auto save after window change.
+     */
+    WINDOW_CHANGE = 4
+}
+type SaveSource = string;
+interface ISaveOptions {
+    /**
+     * An indicator how the save operation was triggered.
+     */
+    reason?: SaveReason;
+    /**
+     * An indicator about the source of the save operation.
+     *
+     * Must use `SaveSourceRegistry.registerSource()` to obtain.
+     */
+    readonly source?: SaveSource;
+    /**
+     * Forces to save the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * Instructs the save operation to skip any save participants.
+     */
+    readonly skipSaveParticipants?: boolean;
+    /**
+     * A hint as to which file systems should be available for saving.
+     */
+    readonly availableFileSystems?: string[];
+}
+interface IRevertOptions {
+    /**
+     * Forces to load the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * A soft revert will clear dirty state of a working copy
+     * but will not attempt to load it from its persisted state.
+     *
+     * This option may be used in scenarios where an editor is
+     * closed and where we do not require to load the contents.
+     */
+    readonly soft?: boolean;
+}
+
+declare const enum WorkingCopyCapabilities {
+    /**
+     * Signals no specific capability for the working copy.
+     */
+    None = 0,
+    /**
+     * Signals that the working copy requires
+     * additional input when saving, e.g. an
+     * associated path to save to.
+     */
+    Untitled = 2
+}
+/**
+ * Data to be associated with working copy backups. Use
+ * `IWorkingCopyBackupService.resolve(workingCopy)` to
+ * retrieve the backup when loading the working copy.
+ */
+interface IWorkingCopyBackup {
+    /**
+     * Any serializable metadata to be associated with the backup.
+     */
+    meta?: IWorkingCopyBackupMeta;
+    /**
+     * The actual snapshot of the contents of the working copy at
+     * the time the backup was made.
+     */
+    content?: VSBufferReadable | VSBufferReadableStream;
+}
+/**
+ * Working copy backup metadata that can be associated
+ * with the backup.
+ *
+ * Some properties may be reserved as outlined here and
+ * cannot be used.
+ */
+interface IWorkingCopyBackupMeta {
+    /**
+     * Any property needs to be serializable through JSON.
+     */
+    [key: string]: unknown;
+    /**
+     * `typeId` is a reserved property that cannot be used
+     * as backup metadata.
+     */
+    typeId?: never;
+}
+/**
+ * Every working copy has in common that it is identified by
+ * a resource `URI` and a `typeId`. There can only be one
+ * working copy registered with the same `URI` and `typeId`.
+ */
+interface IWorkingCopyIdentifier {
+    /**
+     * The type identifier of the working copy for grouping
+     * working copies of the same domain together.
+     *
+     * There can only be one working copy for a given resource
+     * and type identifier.
+     */
+    readonly typeId: string;
+    /**
+     * The resource of the working copy must be unique for
+     * working copies of the same `typeId`.
+     */
+    readonly resource: URI;
+}
+interface IWorkingCopySaveEvent {
+    /**
+     * The reason why the working copy was saved.
+     */
+    readonly reason?: SaveReason;
+    /**
+     * The source of the working copy save request.
+     */
+    readonly source?: SaveSource;
+}
+/**
+ * A working copy is an abstract concept to unify handling of
+ * data that can be worked on (e.g. edited) in an editor.
+ *
+ *
+ * A working copy resource may be the backing store of the data
+ * (e.g. a file on disk), but that is not a requirement. If
+ * your working copy is file based, consider to use the
+ * `IFileWorkingCopy` instead that simplifies a lot of things
+ * when working with file based working copies.
+ */
+interface IWorkingCopy extends IWorkingCopyIdentifier {
+    /**
+     * Human readable name of the working copy.
+     */
+    readonly name: string;
+    /**
+     * The capabilities of the working copy.
+     */
+    readonly capabilities: WorkingCopyCapabilities;
+    /**
+     * Used by the workbench to signal if the working copy
+     * is dirty or not. Typically a working copy is dirty
+     * once changed until saved or reverted.
+     */
+    readonly onDidChangeDirty: Event<void>;
+    /**
+     * Used by the workbench e.g. to trigger auto-save
+     * (unless this working copy is untitled) and backups.
+     */
+    readonly onDidChangeContent: Event<void>;
+    /**
+     * Used by the workbench e.g. to track local history
+     * (unless this working copy is untitled).
+     */
+    readonly onDidSave: Event<IWorkingCopySaveEvent>;
+    isDirty(): boolean;
+    /**
+     * The workbench may call this method often after it receives
+     * the `onDidChangeContent` event for the working copy. The motivation
+     * is to allow to quit VSCode with dirty working copies present.
+     *
+     * Providers of working copies should use `IWorkingCopyBackupService.resolve(workingCopy)`
+     * to retrieve the backup metadata associated when loading the working copy.
+     *
+     * @param token support for cancellation
+     */
+    backup(token: CancellationToken): Promise<IWorkingCopyBackup>;
+    /**
+     * Asks the working copy to save. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     *
+     * @returns `true` if the operation was successful and `false` otherwise.
+     */
+    save(options?: ISaveOptions): Promise<boolean>;
+    /**
+     * Asks the working copy to revert. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     */
+    revert(options?: IRevertOptions): Promise<void>;
+}
+
+/**
+ * States the text file editor model can be in.
+ */
+declare const enum TextFileEditorModelState {
+    /**
+     * A model is saved.
+     */
+    SAVED = 0,
+    /**
+     * A model is dirty.
+     */
+    DIRTY = 1,
+    /**
+     * A model is currently being saved but this operation has not completed yet.
+     */
+    PENDING_SAVE = 2,
+    /**
+     * A model is in conflict mode when changes cannot be saved because the
+     * underlying file has changed. Models in conflict mode are always dirty.
+     */
+    CONFLICT = 3,
+    /**
+     * A model is in orphan state when the underlying file has been deleted.
+     */
+    ORPHAN = 4,
+    /**
+     * Any error that happens during a save that is not causing the CONFLICT state.
+     * Models in error mode are always dirty.
+     */
+    ERROR = 5
+}
+declare const enum TextFileResolveReason {
+    EDITOR = 1,
+    REFERENCE = 2,
+    OTHER = 3
+}
+interface ITextFileSaveOptions extends ISaveOptions {
+    /**
+     * Save the file with an attempt to unlock it.
+     */
+    readonly writeUnlock?: boolean;
+    /**
+     * Save the file with elevated privileges.
+     *
+     * Note: This may not be supported in all environments.
+     */
+    readonly writeElevated?: boolean;
+    /**
+     * Allows to write to a file even if it has been modified on disk.
+     */
+    readonly ignoreModifiedSince?: boolean;
+    /**
+     * If set, will bubble up the error to the caller instead of handling it.
+     */
+    readonly ignoreErrorHandler?: boolean;
+}
+interface ITextFileResolveOptions {
+    /**
+     * The contents to use for the model if known. If not
+     * provided, the contents will be retrieved from the
+     * underlying resource or backup if present.
+     */
+    readonly contents?: ITextBufferFactory;
+    /**
+     * Go to file bypassing any cache of the model if any.
+     */
+    readonly forceReadFromFile?: boolean;
+    /**
+     * Allow to resolve a model even if we think it is a binary file.
+     */
+    readonly allowBinary?: boolean;
+    /**
+     * Context why the model is being resolved.
+     */
+    readonly reason?: TextFileResolveReason;
+    /**
+     * If provided, the size of the file will be checked against the limits
+     * and an error will be thrown if any limit is exceeded.
+     */
+    readonly limits?: IFileReadLimits;
+}
+declare const enum EncodingMode {
+    /**
+     * Instructs the encoding support to encode the object with the provided encoding
+     */
+    Encode = 0,
+    /**
+     * Instructs the encoding support to decode the object with the provided encoding
+     */
+    Decode = 1
+}
+interface IEncodingSupport {
+    /**
+     * Gets the encoding of the object if known.
+     */
+    getEncoding(): string | undefined;
+    /**
+     * Sets the encoding for the object for saving.
+     */
+    setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
+}
+interface ILanguageSupport {
+    /**
+     * Sets the language id of the object.
+     */
+    setLanguageId(languageId: string, source?: string): void;
+}
+interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
+    readonly stat: IFileStatWithMetadata;
+}
+interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {
+    readonly onDidSave: Event<ITextFileEditorModelSaveEvent>;
+    readonly onDidSaveError: Event<void>;
+    readonly onDidChangeOrphaned: Event<void>;
+    readonly onDidChangeReadonly: Event<void>;
+    readonly onDidChangeEncoding: Event<void>;
+    hasState(state: TextFileEditorModelState): boolean;
+    joinState(state: TextFileEditorModelState.PENDING_SAVE): Promise<void>;
+    updatePreferredEncoding(encoding: string | undefined): void;
+    save(options?: ITextFileSaveOptions): Promise<boolean>;
+    revert(options?: IRevertOptions): Promise<void>;
+    resolve(options?: ITextFileResolveOptions): Promise<void>;
+    isDirty(): this is IResolvedTextFileEditorModel;
+    getLanguageId(): string | undefined;
+    isResolved(): this is IResolvedTextFileEditorModel;
+}
+interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
+    readonly textEditorModel: ITextModel;
+    createSnapshot(): ITextSnapshot;
+}
+
+declare function writeFile(uri: URI, content: string): Promise<void>;
+declare function deleteFile(uri: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
+declare function createModelReference(resource: URI, content?: string): Promise<IReference<ITextFileEditorModel>>;
 declare const createConfiguredEditor: typeof create;
 declare const createConfiguredDiffEditor: typeof createDiffEditor;
 declare const Extensions: {
     Configuration: string;
     JSONContribution: string;
 };
-type FileMatch = Partial<Record<string, string[]>>;
-declare function getJsonSchemas(fileMatchs?: FileMatch): monaco.languages.json.DiagnosticsOptions['schemas'];
-declare const onDidChangeJsonSchema: Event<string>;
+/**
+ * Synchronize registered json schema on the monaco json worker
+ */
+declare function synchronizeJsonSchemas(): monaco.IDisposable;
 
-export { CommandsRegistry, ContextKeyExprType, DisposableStore, Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, errorHandler, getJsonSchemas, onDidChangeJsonSchema, registerColor, setCollapseStateForMatchingLines };
+export { CommandsRegistry, ContextKeyExprType, DisposableStore, Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, errorHandler, registerColor, setCollapseStateForMatchingLines, synchronizeJsonSchemas, writeFile };