@codingame/monaco-vscode-api 1.68.7 → 1.69.2

package/dist/textmate.d.ts

@@ -0,0 +1,683 @@
+import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode';
+import { IGrammar as IGrammar$1 } from 'vscode-textmate';
+
+/**
+ * Identifies a service of type `T`.
+ */
+interface ServiceIdentifier<T> {
+    (...args: any[]): void;
+    type: T;
+}
+
+interface IDisposable {
+    dispose(): void;
+}
+declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private _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;
+    /**
+     * Returns `true` if this object has been disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    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;
+}
+
+/**
+ * To an event a function with one or zero parameters
+ * can be subscribed. The event is the subscriber function itself.
+ */
+type Event<T> = vscode.Event<T>
+declare namespace Event {
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    function once<T>(event: Event<T>): Event<T>;
+    /**
+     * *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 map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
+    /**
+     * *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 forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
+    /**
+     * *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 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>;
+    /**
+     * *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 debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+    /**
+     * *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 debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    /**
+     * *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 latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
+    /**
+     * *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 split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
+    /**
+     * *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 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, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: 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;
+    }
+    function chain<T>(event: Event<T>): IChainableEvent<T>;
+    interface NodeEventEmitter {
+        on(event: string | symbol, listener: Function): unknown;
+        removeListener(event: string | symbol, listener: Function): unknown;
+    }
+    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;
+    }
+    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    function toPromise<T>(event: Event<T>): Promise<T>;
+    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
+    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;
+}
+
+/**
+ * Type of extension.
+ *
+ * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
+ */
+declare type ExtensionKind = 'ui' | 'workspace' | 'web';
+
+interface ICommand {
+    command: string;
+    title: string;
+    category?: string;
+}
+interface IConfigurationProperty {
+    description: string;
+    type: string | string[];
+    default?: any;
+}
+interface IConfiguration {
+    id?: string;
+    order?: number;
+    title?: string;
+    properties: {
+        [key: string]: IConfigurationProperty;
+    };
+}
+interface IDebugger {
+    label?: string;
+    type: string;
+    runtime?: string;
+}
+interface IGrammar {
+    language: string;
+}
+interface IJSONValidation {
+    fileMatch: string | string[];
+    url: string;
+}
+interface IKeyBinding {
+    command: string;
+    key: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+}
+interface ILanguage {
+    id: string;
+    extensions: string[];
+    aliases: string[];
+}
+interface IMenu {
+    command: string;
+    alt?: string;
+    when?: string;
+    group?: string;
+}
+interface ISnippet {
+    language: string;
+}
+interface ITheme {
+    label: string;
+}
+interface IViewContainer {
+    id: string;
+    title: string;
+}
+interface IView {
+    id: string;
+    name: string;
+}
+interface IColor {
+    id: string;
+    description: string;
+    defaults: {
+        light: string;
+        dark: string;
+        highContrast: string;
+    };
+}
+interface IWebviewEditor {
+    readonly viewType: string;
+    readonly priority: string;
+    readonly selector: readonly {
+        readonly filenamePattern?: string;
+    }[];
+}
+interface ICodeActionContributionAction {
+    readonly kind: string;
+    readonly title: string;
+    readonly description?: string;
+}
+interface ICodeActionContribution {
+    readonly languages: readonly string[];
+    readonly actions: readonly ICodeActionContributionAction[];
+}
+interface IAuthenticationContribution {
+    readonly id: string;
+    readonly label: string;
+}
+interface IWalkthroughStep {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string | undefined;
+    readonly media: {
+        image: string | {
+            dark: string;
+            light: string;
+            hc: string;
+        };
+        altText: string;
+        markdown?: never;
+        svg?: never;
+    } | {
+        markdown: string;
+        image?: never;
+        svg?: never;
+    } | {
+        svg: string;
+        altText: string;
+        markdown?: never;
+        image?: never;
+    };
+    readonly completionEvents?: string[];
+    /** @deprecated use `completionEvents: 'onCommand:...'` */
+    readonly doneOn?: {
+        command: string;
+    };
+    readonly when?: string;
+}
+interface IWalkthrough {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly steps: IWalkthroughStep[];
+    readonly featuredFor: string[] | undefined;
+    readonly when?: string;
+}
+interface IStartEntry {
+    readonly title: string;
+    readonly description: string;
+    readonly command: string;
+    readonly when?: string;
+    readonly category: 'file' | 'folder' | 'notebook';
+}
+interface INotebookEntry {
+    readonly type: string;
+    readonly displayName: string;
+}
+interface INotebookRendererContribution {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+}
+interface ITranslation {
+    id: string;
+    path: string;
+}
+interface ILocalizationContribution {
+    languageId: string;
+    languageName?: string;
+    localizedLanguageName?: string;
+    translations: ITranslation[];
+    minimalTranslations?: {
+        [key: string]: string;
+    };
+}
+interface IExtensionContributions {
+    commands?: ICommand[];
+    configuration?: IConfiguration | IConfiguration[];
+    debuggers?: IDebugger[];
+    grammars?: IGrammar[];
+    jsonValidation?: IJSONValidation[];
+    keybindings?: IKeyBinding[];
+    languages?: ILanguage[];
+    menus?: {
+        [context: string]: IMenu[];
+    };
+    snippets?: ISnippet[];
+    themes?: ITheme[];
+    iconThemes?: ITheme[];
+    productIconThemes?: ITheme[];
+    viewsContainers?: {
+        [location: string]: IViewContainer[];
+    };
+    views?: {
+        [location: string]: IView[];
+    };
+    colors?: IColor[];
+    localizations?: ILocalizationContribution[];
+    readonly customEditors?: readonly IWebviewEditor[];
+    readonly codeActions?: readonly ICodeActionContribution[];
+    authentication?: IAuthenticationContribution[];
+    walkthroughs?: IWalkthrough[];
+    startEntries?: IStartEntry[];
+    readonly notebooks?: INotebookEntry[];
+    readonly notebookRenderer?: INotebookRendererContribution[];
+}
+interface IExtensionCapabilities {
+    readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
+    readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
+}
+declare type LimitedWorkspaceSupportType = 'limited';
+declare type ExtensionUntrustedWorkspaceSupport = {
+    supported: true;
+} | {
+    supported: false;
+    description: string;
+} | {
+    supported: LimitedWorkspaceSupportType;
+    description: string;
+    restrictedConfigurations?: string[];
+};
+declare type ExtensionVirtualWorkspaceSupport = boolean | {
+    supported: true;
+} | {
+    supported: false | LimitedWorkspaceSupportType;
+    description: string;
+};
+interface IRelaxedExtensionManifest {
+    name: string;
+    displayName?: string;
+    publisher: string;
+    version: string;
+    engines: {
+        readonly vscode: string;
+    };
+    description?: string;
+    main?: string;
+    browser?: string;
+    icon?: string;
+    categories?: string[];
+    keywords?: string[];
+    activationEvents?: string[];
+    extensionDependencies?: string[];
+    extensionPack?: string[];
+    extensionKind?: ExtensionKind | ExtensionKind[];
+    contributes?: IExtensionContributions;
+    repository?: {
+        url: string;
+    };
+    bugs?: {
+        url: string;
+    };
+    enabledApiProposals?: readonly string[];
+    api?: string;
+    scripts?: {
+        [key: string]: string;
+    };
+    capabilities?: IExtensionCapabilities;
+}
+declare const enum TargetPlatform {
+    WIN32_X64 = "win32-x64",
+    WIN32_IA32 = "win32-ia32",
+    WIN32_ARM64 = "win32-arm64",
+    LINUX_X64 = "linux-x64",
+    LINUX_ARM64 = "linux-arm64",
+    LINUX_ARMHF = "linux-armhf",
+    ALPINE_X64 = "alpine-x64",
+    ALPINE_ARM64 = "alpine-arm64",
+    DARWIN_X64 = "darwin-x64",
+    DARWIN_ARM64 = "darwin-arm64",
+    WEB = "web",
+    UNIVERSAL = "universal",
+    UNKNOWN = "unknown",
+    UNDEFINED = "undefined"
+}
+/**
+ * **!Do not construct directly!**
+ *
+ * **!Only static methods because it gets serialized!**
+ *
+ * This represents the "canonical" version for an extension identifier. Extension ids
+ * have to be case-insensitive (due to the marketplace), but we must ensure case
+ * preservation because the extension API is already public at this time.
+ *
+ * For example, given an extension with the publisher `"Hello"` and the name `"World"`,
+ * its canonical extension identifier is `"Hello.World"`. This extension could be
+ * referenced in some other extension's dependencies using the string `"hello.world"`.
+ *
+ * To make matters more complicated, an extension can optionally have an UUID. When two
+ * extensions have the same UUID, they are considered equal even if their identifier is different.
+ */
+declare class ExtensionIdentifier {
+    readonly value: string;
+    private readonly _lower;
+    constructor(value: string);
+    static equals(a: ExtensionIdentifier | string | null | undefined, b: ExtensionIdentifier | string | null | undefined): boolean;
+    /**
+     * Gives the value by which to index (for equality).
+     */
+    static toKey(id: ExtensionIdentifier | string): string;
+}
+interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
+    id?: string;
+    identifier: ExtensionIdentifier;
+    uuid?: string;
+    targetPlatform: TargetPlatform;
+    isBuiltin: boolean;
+    isUserBuiltin: boolean;
+    isUnderDevelopment: boolean;
+    extensionLocation: URI;
+}
+declare type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+declare const ITextMateService: ServiceIdentifier<ITextMateService>;
+interface ITextMateService {
+    readonly _serviceBrand: undefined;
+    onDidEncounterLanguage: Event<string>;
+    createGrammar(languageId: string): Promise<IGrammar$1 | null>;
+    startDebugMode(printFn: (str: string) => void, onStop: () => void): void;
+}
+
+interface IEmbeddedLanguagesMap {
+    [scopeName: string]: string;
+}
+interface TokenTypesContribution {
+    [scopeName: string]: string;
+}
+interface ITMSyntaxExtensionPoint {
+    language: string;
+    scopeName: string;
+    path: string;
+    embeddedLanguages: IEmbeddedLanguagesMap;
+    tokenTypes: TokenTypesContribution;
+    injectTo: string[];
+    balancedBracketScopes: string[];
+    unbalancedBracketScopes: string[];
+}
+
+declare type PartialITMSyntaxExtensionPoint = Partial<ITMSyntaxExtensionPoint> & Pick<ITMSyntaxExtensionPoint, 'path' | 'scopeName'>;
+declare function setGrammars<T extends PartialITMSyntaxExtensionPoint>(grammars: T[], getContent: (grammar: T) => Promise<string>, extension?: IExtensionDescription): void;
+declare function getServiceOverride(getOnigLib: () => Promise<Response | ArrayBuffer>): IEditorOverrideServices;
+
+export { PartialITMSyntaxExtensionPoint as ITMSyntaxExtensionPoint, ITextMateService, getServiceOverride as default, setGrammars };