interface IDisposableTracker {
    trackDisposable(x: IDisposable): void;
    markTracked(x: IDisposable): void;
}
declare function setDisposableTracker(tracker: IDisposableTracker | null): void;
declare function trackDisposable<T extends IDisposable>(x: T): T;
declare class MultiDisposeError extends Error {
    readonly errors: any[];
    constructor(errors: any[]);
}
interface IDisposable {
    dispose(): void;
}
declare function isDisposable<E extends object>(thing: E): thing is E & IDisposable;
declare function dispose<T extends IDisposable>(disposable: T): T;
declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
declare function dispose<T extends IDisposable, A extends IterableIterator<T> = IterableIterator<T>>(disposables: IterableIterator<T>): A;
declare function dispose<T extends IDisposable>(disposables: Array<T>): Array<T>;
declare function dispose<T extends IDisposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;
declare function combinedDisposable(...disposables: IDisposable[]): IDisposable;
declare function toDisposable(fn: () => void): IDisposable;
declare class DisposableStore implements IDisposable {
    static DISABLE_DISPOSED_WARNING: boolean;
    private _toDispose;
    private _isDisposed;
    /**
     * 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;
    /**
     * Dispose of all registered disposables but do not mark this object as disposed.
     */
    clear(): void;
    add<T extends IDisposable>(t: T): T;
}
declare abstract class Disposable implements IDisposable {
    static readonly None: Readonly<IDisposable>;
    private readonly _store;
    constructor();
    dispose(): void;
    protected _register<T extends IDisposable>(t: T): T;
}
/**
 * Manages the lifecycle of a disposable value that may be changed.
 *
 * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
 * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
 */
declare class MutableDisposable<T extends IDisposable> implements IDisposable {
    private _value?;
    private _isDisposed;
    constructor();
    get value(): T | undefined;
    set value(value: T | undefined);
    clear(): void;
    dispose(): void;
}
interface IReference<T> extends IDisposable {
    readonly object: T;
}
declare abstract class ReferenceCollection<T> {
    private readonly references;
    acquire(key: string, ...args: any[]): IReference<T>;
    protected abstract createReferencedObject(key: string, ...args: any[]): T;
    protected abstract destroyReferencedObject(key: string, object: T): void;
}
declare class ImmortalReference<T> implements IReference<T> {
    object: T;
    constructor(object: T);
    dispose(): void;
}
interface CancellationToken {
    /**
     * A flag signalling is cancellation has been requested.
     */
    readonly isCancellationRequested: boolean;
    /**
     * An event which fires when cancellation is requested. This event
     * only ever fires `once` as cancellation can only happen once. Listeners
     * that are registered after cancellation will be called (next event loop run),
     * but also only once.
     *
     * @event
     */
    readonly onCancellationRequested: (listener: (e: any) => any, thisArgs?: any, disposables?: IDisposable[]) => IDisposable;
}
declare namespace CancellationToken {
    function isCancellationToken(thing: unknown): thing is CancellationToken;
    const None: CancellationToken;
    const Cancelled: CancellationToken;
}
declare class CancellationTokenSource {
    private _token?;
    private _parentListener?;
    constructor(parent?: CancellationToken);
    get token(): CancellationToken;
    cancel(): void;
    dispose(cancel?: boolean): void;
}
declare class LinkedList<E> {
    private _first;
    private _last;
    private _size;
    get size(): number;
    isEmpty(): boolean;
    clear(): void;
    unshift(element: E): () => void;
    push(element: E): () => void;
    private _insert;
    shift(): E | undefined;
    pop(): E | undefined;
    private _remove;
    [Symbol.iterator](): Iterator<E>;
}
/**
 * To an event a function with one or zero parameters
 * can be subscribed. The event is the subscriber function itself.
 */
interface Event<T> {
    (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
}
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>;
    /**
     * Given an event and a `map` function, returns another event which maps each element
     * through the mapping function.
     */
    function map<I, O>(event: Event<I>, map: (i: I) => O): Event<O>;
    /**
     * Given an event and an `each` function, returns another identical event and calls
     * the `each` function per each element.
     */
    function forEach<I>(event: Event<I>, each: (i: I) => void): Event<I>;
    /**
     * Given an event and a `filter` function, returns another event which emits those
     * elements for which the `filter` function returns `true`.
     */
    function filter<T>(event: Event<T>, filter: (e: T) => boolean): Event<T>;
    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R): 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>;
    /**
     * Given an event and a `merge` function, returns another event which maps each element
     * and the cumulative result through the `merge` function. Similar to `map`, but with memory.
     */
    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O): Event<O>;
    /**
     * Given a chain of event processing functions (filter, map, etc), each
     * function will be invoked per event & per listener. Snapshotting an event
     * chain allows each function to be invoked just once per event.
     */
    function snapshot<T>(event: Event<T>): Event<T>;
    /**
     * Debounces the provided event, given a `merge` function.
     *
     * @param event The input event.
     * @param merge The reducing function.
     * @param delay The debouncing delay in millis.
     * @param leading Whether the event should fire in the leading phase of the timeout.
     * @param leakWarningThreshold The leak warning threshold override.
     */
    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event<T>;
    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event<O>;
    /**
     * Given an event, it returns another event which fires only once and as soon as
     * the input event emits. The event data is the number of millis it took for the
     * event to fire.
     */
    function stopwatch<T>(event: Event<T>): Event<number>;
    /**
     * Given an event, it returns another event which fires only when the event
     * element changes.
     */
    function latch<T>(event: Event<T>): Event<T>;
    /**
     * Buffers the provided event until a first listener comes
     * along, at which point fire all the events at once and
     * pipe the event from then on.
     *
     * ```typescript
     * const emitter = new Emitter<number>();
     * const event = emitter.event;
     * const bufferedEvent = buffer(event);
     *
     * emitter.fire(1);
     * emitter.fire(2);
     * emitter.fire(3);
     * // nothing...
     *
     * const listener = bufferedEvent(num => console.log(num));
     * // 1, 2, 3
     *
     * emitter.fire(4);
     * // 4
     * ```
     */
    function buffer<T>(event: Event<T>, nextTick?: boolean, _buffer?: T[]): Event<T>;
    interface IChainableEvent<T> {
        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 fromPromise<T = any>(promise: Promise<T>): Event<undefined>;
    function toPromise<T>(event: Event<T>): Promise<T>;
}
type Listener<T> = [
    (e: T) => void,
    any
] | ((e: T) => void);
interface EmitterOptions {
    onFirstListenerAdd?: Function;
    onFirstListenerDidAdd?: Function;
    onListenerDidAdd?: Function;
    onLastListenerRemove?: Function;
    leakWarningThreshold?: number;
    /** ONLY enable this during development */
    _profName?: string;
}
declare function setGlobalLeakWarningThreshold(n: number): IDisposable;
/**
 * The Emitter can be used to expose an Event to the public
 * to fire it from the insides.
 * Sample:
 class Document {
 
 private readonly _onDidChange = new Emitter<(value:string)=>any>();
 
 public onDidChange = this._onDidChange.event;
 
 // getter-style
 // get onDidChange(): Event<(value:string)=>any> {
 // 	return this._onDidChange.event;
 // }
 
 private _doIt() {
 //...
 this._onDidChange.fire(value);
 }
 }
 */
declare class Emitter<T> {
    private static readonly _noop;
    private readonly _options?;
    private readonly _leakageMon?;
    private readonly _perfMon?;
    private _disposed;
    private _event?;
    private _deliveryQueue?;
    protected _listeners?: LinkedList<Listener<T>>;
    constructor(options?: EmitterOptions);
    /**
     * For the public to allow to subscribe
     * to events from this Emitter
     */
    get event(): Event<T>;
    /**
     * To be kept private to fire an event to
     * subscribers
     */
    fire(event: T): void;
    dispose(): void;
}
declare class PauseableEmitter<T> extends Emitter<T> {
    private _isPaused;
    private _eventQueue;
    private _mergeFn?;
    constructor(options?: EmitterOptions & {
        merge?: (input: T[]) => T;
    });
    pause(): void;
    resume(): void;
    fire(event: T): void;
}
interface IWaitUntil {
    waitUntil(thenable: Promise<any>): void;
}
declare class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
    private _asyncDeliveryQueue?;
    fireAsync(data: Omit<T, "waitUntil">, token: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
}
declare class EventMultiplexer<T> implements IDisposable {
    private readonly emitter;
    private hasListeners;
    private events;
    constructor();
    get event(): Event<T>;
    add(event: Event<T>): IDisposable;
    private onFirstListenerAdd;
    private onLastListenerRemove;
    private hook;
    private unhook;
    dispose(): void;
}
/**
 * The EventBufferer is useful in situations in which you want
 * to delay firing your events during some code.
 * You can wrap that code and be sure that the event will not
 * be fired during that wrap.
 *
 * ```
 * const emitter: Emitter;
 * const delayer = new EventDelayer();
 * const delayedEvent = delayer.wrapEvent(emitter.event);
 *
 * delayedEvent(console.log);
 *
 * delayer.bufferEvents(() => {
 *   emitter.fire(); // event will not be fired yet
 * });
 *
 * // event will only be fired at this point
 * ```
 */
declare class EventBufferer {
    private buffers;
    wrapEvent<T>(event: Event<T>): Event<T>;
    bufferEvents<R = void>(fn: () => R): R;
}
/**
 * A Relay is an event forwarder which functions as a replugabble event pipe.
 * Once created, you can connect an input event to it and it will simply forward
 * events from that input event through its own `event` property. The `input`
 * can be changed at any point in time.
 */
declare class Relay<T> implements IDisposable {
    private listening;
    private inputEvent;
    private inputEventListener;
    private readonly emitter;
    readonly event: Event<T>;
    set input(event: Event<T>);
    dispose(): void;
}
/**
 * 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.msft.com/some/path?query#fragment'.
     * The part before the first colon.
     */
    readonly scheme: string;
    /**
     * authority is the 'www.msft.com' part of 'http://www.msft.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.msft.com/some/path?query#fragment'.
     */
    readonly path: string;
    /**
     * query is the 'query' part of 'http://www.msft.com/some/path?query#fragment'.
     */
    readonly query: string;
    /**
     * fragment is the 'fragment' part of 'http://www.msft.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);
    // ---- filesystem path -----------------------
    /**
     * 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;
    // ---- modify to new -------------------------
    with(change: {
        scheme?: string;
        authority?: string | null;
        path?: string | null;
        query?: string | null;
        fragment?: string | null;
    }): URI;
    // ---- parse & validate ------------------------
    /**
     * Creates a new URI from a string, e.g. `http://www.msft.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;
    // ---- printing/externalize ---------------------------
    /**
     * 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;
}
/**
 * Compute `fsPath` for the given uri
 */
declare function uriToFsPath(uri: URI, keepDriveLetterCasing: boolean): string;
declare function isThenable<T>(obj: any): obj is Promise<T>;
interface CancelablePromise<T> extends Promise<T> {
    cancel(): void;
}
declare function createCancelablePromise<T>(callback: (token: CancellationToken) => Promise<T>): CancelablePromise<T>;
declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken): Promise<T | undefined>;
declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken, defaultValue: T): Promise<T>;
declare function asPromise<T>(callback: () => T | Thenable<T>): Promise<T>;
interface ITask<T> {
    (): T;
}
/**
 * A helper to prevent accumulation of sequential async tasks.
 *
 * Imagine a mail man with the sole task of delivering letters. As soon as
 * a letter submitted for delivery, he drives to the destination, delivers it
 * and returns to his base. Imagine that during the trip, N more letters were submitted.
 * When the mail man returns, he picks those N letters and delivers them all in a
 * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
 *
 * The throttler implements this via the queue() method, by providing it a task
 * factory. Following the example:
 *
 * 		const throttler = new Throttler();
 * 		const letters = [];
 *
 * 		function deliver() {
 * 			const lettersToDeliver = letters;
 * 			letters = [];
 * 			return makeTheTrip(lettersToDeliver);
 * 		}
 *
 * 		function onLetterReceived(l) {
 * 			letters.push(l);
 * 			throttler.queue(deliver);
 * 		}
 */
declare class Throttler {
    private activePromise;
    private queuedPromise;
    private queuedPromiseFactory;
    constructor();
    queue<T>(promiseFactory: ITask<Promise<T>>): Promise<T>;
}
declare class Sequencer {
    private current;
    queue<T>(promiseTask: ITask<Promise<T>>): Promise<T>;
}
/**
 * A helper to delay (debounce) execution of a task that is being requested often.
 *
 * Following the throttler, now imagine the mail man wants to optimize the number of
 * trips proactively. The trip itself can be long, so he decides not to make the trip
 * as soon as a letter is submitted. Instead he waits a while, in case more
 * letters are submitted. After said waiting period, if no letters were submitted, he
 * decides to make the trip. Imagine that N more letters were submitted after the first
 * one, all within a short period of time between each other. Even though N+1
 * submissions occurred, only 1 delivery was made.
 *
 * The delayer offers this behavior via the trigger() method, into which both the task
 * to be executed and the waiting period (delay) must be passed in as arguments. Following
 * the example:
 *
 * 		const delayer = new Delayer(WAITING_PERIOD);
 * 		const letters = [];
 *
 * 		function letterReceived(l) {
 * 			letters.push(l);
 * 			delayer.trigger(() => { return makeTheTrip(); });
 * 		}
 */
declare class Delayer<T> implements IDisposable {
    defaultDelay: number;
    private timeout;
    private completionPromise;
    private doResolve;
    private doReject;
    private task;
    constructor(defaultDelay: number);
    trigger(task: ITask<T | Promise<T>>, delay?: number): Promise<T>;
    isTriggered(): boolean;
    cancel(): void;
    private cancelTimeout;
    dispose(): void;
}
/**
 * A helper to delay execution of a task that is being requested often, while
 * preventing accumulation of consecutive executions, while the task runs.
 *
 * The mail man is clever and waits for a certain amount of time, before going
 * out to deliver letters. While the mail man is going out, more letters arrive
 * and can only be delivered once he is back. Once he is back the mail man will
 * do one more trip to deliver the letters that have accumulated while he was out.
 */
declare class ThrottledDelayer<T> {
    private delayer;
    private throttler;
    constructor(defaultDelay: number);
    trigger(promiseFactory: ITask<Promise<T>>, delay?: number): Promise<T>;
    isTriggered(): boolean;
    cancel(): void;
    dispose(): void;
}
/**
 * A barrier that is initially closed and then becomes opened permanently.
 */
declare class Barrier {
    private _isOpen;
    private _promise;
    private _completePromise;
    constructor();
    isOpen(): boolean;
    open(): void;
    wait(): Promise<boolean>;
}
declare function timeout(millis: number): CancelablePromise<void>;
declare function timeout(millis: number, token: CancellationToken): Promise<void>;
declare function disposableTimeout(handler: () => void, timeout?: number): IDisposable;
declare function ignoreErrors<T>(promise: Promise<T>): Promise<T | undefined>;
/**
 * Runs the provided list of promise factories in sequential order. The returned
 * promise will complete to an array of results from each promise.
 */
declare function sequence<T>(promiseFactories: ITask<Promise<T>>[]): Promise<T[]>;
declare function first<T>(promiseFactories: ITask<Promise<T>>[], shouldStop?: (t: T) => boolean, defaultValue?: T | null): Promise<T | null>;
/**
 * A helper to queue N promises and run them all with a max degree of parallelism. The helper
 * ensures that at any time no more than M promises are running at the same time.
 */
declare class Limiter<T> {
    private _size;
    private runningPromises;
    private maxDegreeOfParalellism;
    private outstandingPromises;
    private readonly _onFinished;
    constructor(maxDegreeOfParalellism: number);
    get onFinished(): Event<void>;
    get size(): number;
    queue(factory: ITask<Promise<T>>): Promise<T>;
    private consume;
    private consumed;
    dispose(): void;
}
/**
 * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
 */
declare class Queue<T> extends Limiter<T> {
    constructor();
}
//#endregion
declare function retry<T>(task: ITask<Promise<T>>, delay: number, retries: number): Promise<T>;
/*---------------------------------------------------------------------------------------------
*  Copyright (c) Microsoft Corporation. All rights reserved.
*  Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Names from https://blog.codinghorror.com/ascii-pronunciation-rules-for-programmers/
/**
 * An inlined enum containing useful character codes (to be used with String.charCodeAt).
 * Please leave the const keyword such that it gets inlined when compiled to JavaScript!
 */
declare const enum CharCode {
    Null = 0,
    /**
     * The `\b` character.
     */
    Backspace = 8,
    /**
     * The `\t` character.
     */
    Tab = 9,
    /**
     * The `\n` character.
     */
    LineFeed = 10,
    /**
     * The `\r` character.
     */
    CarriageReturn = 13,
    Space = 32,
    /**
     * The `!` character.
     */
    ExclamationMark = 33,
    /**
     * The `"` character.
     */
    DoubleQuote = 34,
    /**
     * The `#` character.
     */
    Hash = 35,
    /**
     * The `$` character.
     */
    DollarSign = 36,
    /**
     * The `%` character.
     */
    PercentSign = 37,
    /**
     * The `&` character.
     */
    Ampersand = 38,
    /**
     * The `'` character.
     */
    SingleQuote = 39,
    /**
     * The `(` character.
     */
    OpenParen = 40,
    /**
     * The `)` character.
     */
    CloseParen = 41,
    /**
     * The `*` character.
     */
    Asterisk = 42,
    /**
     * The `+` character.
     */
    Plus = 43,
    /**
     * The `,` character.
     */
    Comma = 44,
    /**
     * The `-` character.
     */
    Dash = 45,
    /**
     * The `.` character.
     */
    Period = 46,
    /**
     * The `/` character.
     */
    Slash = 47,
    Digit0 = 48,
    Digit1 = 49,
    Digit2 = 50,
    Digit3 = 51,
    Digit4 = 52,
    Digit5 = 53,
    Digit6 = 54,
    Digit7 = 55,
    Digit8 = 56,
    Digit9 = 57,
    /**
     * The `:` character.
     */
    Colon = 58,
    /**
     * The `;` character.
     */
    Semicolon = 59,
    /**
     * The `<` character.
     */
    LessThan = 60,
    /**
     * The `=` character.
     */
    Equals = 61,
    /**
     * The `>` character.
     */
    GreaterThan = 62,
    /**
     * The `?` character.
     */
    QuestionMark = 63,
    /**
     * The `@` character.
     */
    AtSign = 64,
    A = 65,
    B = 66,
    C = 67,
    D = 68,
    E = 69,
    F = 70,
    G = 71,
    H = 72,
    I = 73,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    O = 79,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    U = 85,
    V = 86,
    W = 87,
    X = 88,
    Y = 89,
    Z = 90,
    /**
     * The `[` character.
     */
    OpenSquareBracket = 91,
    /**
     * The `\` character.
     */
    Backslash = 92,
    /**
     * The `]` character.
     */
    CloseSquareBracket = 93,
    /**
     * The `^` character.
     */
    Caret = 94,
    /**
     * The `_` character.
     */
    Underline = 95,
    /**
     * The ``(`)`` character.
     */
    BackTick = 96,
    a = 97,
    b = 98,
    c = 99,
    d = 100,
    e = 101,
    f = 102,
    g = 103,
    h = 104,
    i = 105,
    j = 106,
    k = 107,
    l = 108,
    m = 109,
    n = 110,
    o = 111,
    p = 112,
    q = 113,
    r = 114,
    s = 115,
    t = 116,
    u = 117,
    v = 118,
    w = 119,
    x = 120,
    y = 121,
    z = 122,
    /**
     * The `{` character.
     */
    OpenCurlyBrace = 123,
    /**
     * The `|` character.
     */
    Pipe = 124,
    /**
     * The `}` character.
     */
    CloseCurlyBrace = 125,
    /**
     * The `~` character.
     */
    Tilde = 126,
    U_Combining_Grave_Accent = 768,
    //	U+0300	Combining Grave Accent
    U_Combining_Acute_Accent = 769,
    //	U+0301	Combining Acute Accent
    U_Combining_Circumflex_Accent = 770,
    //	U+0302	Combining Circumflex Accent
    U_Combining_Tilde = 771,
    //	U+0303	Combining Tilde
    U_Combining_Macron = 772,
    //	U+0304	Combining Macron
    U_Combining_Overline = 773,
    //	U+0305	Combining Overline
    U_Combining_Breve = 774,
    //	U+0306	Combining Breve
    U_Combining_Dot_Above = 775,
    //	U+0307	Combining Dot Above
    U_Combining_Diaeresis = 776,
    //	U+0308	Combining Diaeresis
    U_Combining_Hook_Above = 777,
    //	U+0309	Combining Hook Above
    U_Combining_Ring_Above = 778,
    //	U+030A	Combining Ring Above
    U_Combining_Double_Acute_Accent = 779,
    //	U+030B	Combining Double Acute Accent
    U_Combining_Caron = 780,
    //	U+030C	Combining Caron
    U_Combining_Vertical_Line_Above = 781,
    //	U+030D	Combining Vertical Line Above
    U_Combining_Double_Vertical_Line_Above = 782,
    //	U+030E	Combining Double Vertical Line Above
    U_Combining_Double_Grave_Accent = 783,
    //	U+030F	Combining Double Grave Accent
    U_Combining_Candrabindu = 784,
    //	U+0310	Combining Candrabindu
    U_Combining_Inverted_Breve = 785,
    //	U+0311	Combining Inverted Breve
    U_Combining_Turned_Comma_Above = 786,
    //	U+0312	Combining Turned Comma Above
    U_Combining_Comma_Above = 787,
    //	U+0313	Combining Comma Above
    U_Combining_Reversed_Comma_Above = 788,
    //	U+0314	Combining Reversed Comma Above
    U_Combining_Comma_Above_Right = 789,
    //	U+0315	Combining Comma Above Right
    U_Combining_Grave_Accent_Below = 790,
    //	U+0316	Combining Grave Accent Below
    U_Combining_Acute_Accent_Below = 791,
    //	U+0317	Combining Acute Accent Below
    U_Combining_Left_Tack_Below = 792,
    //	U+0318	Combining Left Tack Below
    U_Combining_Right_Tack_Below = 793,
    //	U+0319	Combining Right Tack Below
    U_Combining_Left_Angle_Above = 794,
    //	U+031A	Combining Left Angle Above
    U_Combining_Horn = 795,
    //	U+031B	Combining Horn
    U_Combining_Left_Half_Ring_Below = 796,
    //	U+031C	Combining Left Half Ring Below
    U_Combining_Up_Tack_Below = 797,
    //	U+031D	Combining Up Tack Below
    U_Combining_Down_Tack_Below = 798,
    //	U+031E	Combining Down Tack Below
    U_Combining_Plus_Sign_Below = 799,
    //	U+031F	Combining Plus Sign Below
    U_Combining_Minus_Sign_Below = 800,
    //	U+0320	Combining Minus Sign Below
    U_Combining_Palatalized_Hook_Below = 801,
    //	U+0321	Combining Palatalized Hook Below
    U_Combining_Retroflex_Hook_Below = 802,
    //	U+0322	Combining Retroflex Hook Below
    U_Combining_Dot_Below = 803,
    //	U+0323	Combining Dot Below
    U_Combining_Diaeresis_Below = 804,
    //	U+0324	Combining Diaeresis Below
    U_Combining_Ring_Below = 805,
    //	U+0325	Combining Ring Below
    U_Combining_Comma_Below = 806,
    //	U+0326	Combining Comma Below
    U_Combining_Cedilla = 807,
    //	U+0327	Combining Cedilla
    U_Combining_Ogonek = 808,
    //	U+0328	Combining Ogonek
    U_Combining_Vertical_Line_Below = 809,
    //	U+0329	Combining Vertical Line Below
    U_Combining_Bridge_Below = 810,
    //	U+032A	Combining Bridge Below
    U_Combining_Inverted_Double_Arch_Below = 811,
    //	U+032B	Combining Inverted Double Arch Below
    U_Combining_Caron_Below = 812,
    //	U+032C	Combining Caron Below
    U_Combining_Circumflex_Accent_Below = 813,
    //	U+032D	Combining Circumflex Accent Below
    U_Combining_Breve_Below = 814,
    //	U+032E	Combining Breve Below
    U_Combining_Inverted_Breve_Below = 815,
    //	U+032F	Combining Inverted Breve Below
    U_Combining_Tilde_Below = 816,
    //	U+0330	Combining Tilde Below
    U_Combining_Macron_Below = 817,
    //	U+0331	Combining Macron Below
    U_Combining_Low_Line = 818,
    //	U+0332	Combining Low Line
    U_Combining_Double_Low_Line = 819,
    //	U+0333	Combining Double Low Line
    U_Combining_Tilde_Overlay = 820,
    //	U+0334	Combining Tilde Overlay
    U_Combining_Short_Stroke_Overlay = 821,
    //	U+0335	Combining Short Stroke Overlay
    U_Combining_Long_Stroke_Overlay = 822,
    //	U+0336	Combining Long Stroke Overlay
    U_Combining_Short_Solidus_Overlay = 823,
    //	U+0337	Combining Short Solidus Overlay
    U_Combining_Long_Solidus_Overlay = 824,
    //	U+0338	Combining Long Solidus Overlay
    U_Combining_Right_Half_Ring_Below = 825,
    //	U+0339	Combining Right Half Ring Below
    U_Combining_Inverted_Bridge_Below = 826,
    //	U+033A	Combining Inverted Bridge Below
    U_Combining_Square_Below = 827,
    //	U+033B	Combining Square Below
    U_Combining_Seagull_Below = 828,
    //	U+033C	Combining Seagull Below
    U_Combining_X_Above = 829,
    //	U+033D	Combining X Above
    U_Combining_Vertical_Tilde = 830,
    //	U+033E	Combining Vertical Tilde
    U_Combining_Double_Overline = 831,
    //	U+033F	Combining Double Overline
    U_Combining_Grave_Tone_Mark = 832,
    //	U+0340	Combining Grave Tone Mark
    U_Combining_Acute_Tone_Mark = 833,
    //	U+0341	Combining Acute Tone Mark
    U_Combining_Greek_Perispomeni = 834,
    //	U+0342	Combining Greek Perispomeni
    U_Combining_Greek_Koronis = 835,
    //	U+0343	Combining Greek Koronis
    U_Combining_Greek_Dialytika_Tonos = 836,
    //	U+0344	Combining Greek Dialytika Tonos
    U_Combining_Greek_Ypogegrammeni = 837,
    //	U+0345	Combining Greek Ypogegrammeni
    U_Combining_Bridge_Above = 838,
    //	U+0346	Combining Bridge Above
    U_Combining_Equals_Sign_Below = 839,
    //	U+0347	Combining Equals Sign Below
    U_Combining_Double_Vertical_Line_Below = 840,
    //	U+0348	Combining Double Vertical Line Below
    U_Combining_Left_Angle_Below = 841,
    //	U+0349	Combining Left Angle Below
    U_Combining_Not_Tilde_Above = 842,
    //	U+034A	Combining Not Tilde Above
    U_Combining_Homothetic_Above = 843,
    //	U+034B	Combining Homothetic Above
    U_Combining_Almost_Equal_To_Above = 844,
    //	U+034C	Combining Almost Equal To Above
    U_Combining_Left_Right_Arrow_Below = 845,
    //	U+034D	Combining Left Right Arrow Below
    U_Combining_Upwards_Arrow_Below = 846,
    //	U+034E	Combining Upwards Arrow Below
    U_Combining_Grapheme_Joiner = 847,
    //	U+034F	Combining Grapheme Joiner
    U_Combining_Right_Arrowhead_Above = 848,
    //	U+0350	Combining Right Arrowhead Above
    U_Combining_Left_Half_Ring_Above = 849,
    //	U+0351	Combining Left Half Ring Above
    U_Combining_Fermata = 850,
    //	U+0352	Combining Fermata
    U_Combining_X_Below = 851,
    //	U+0353	Combining X Below
    U_Combining_Left_Arrowhead_Below = 852,
    //	U+0354	Combining Left Arrowhead Below
    U_Combining_Right_Arrowhead_Below = 853,
    //	U+0355	Combining Right Arrowhead Below
    U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below = 854,
    //	U+0356	Combining Right Arrowhead And Up Arrowhead Below
    U_Combining_Right_Half_Ring_Above = 855,
    //	U+0357	Combining Right Half Ring Above
    U_Combining_Dot_Above_Right = 856,
    //	U+0358	Combining Dot Above Right
    U_Combining_Asterisk_Below = 857,
    //	U+0359	Combining Asterisk Below
    U_Combining_Double_Ring_Below = 858,
    //	U+035A	Combining Double Ring Below
    U_Combining_Zigzag_Above = 859,
    //	U+035B	Combining Zigzag Above
    U_Combining_Double_Breve_Below = 860,
    //	U+035C	Combining Double Breve Below
    U_Combining_Double_Breve = 861,
    //	U+035D	Combining Double Breve
    U_Combining_Double_Macron = 862,
    //	U+035E	Combining Double Macron
    U_Combining_Double_Macron_Below = 863,
    //	U+035F	Combining Double Macron Below
    U_Combining_Double_Tilde = 864,
    //	U+0360	Combining Double Tilde
    U_Combining_Double_Inverted_Breve = 865,
    //	U+0361	Combining Double Inverted Breve
    U_Combining_Double_Rightwards_Arrow_Below = 866,
    //	U+0362	Combining Double Rightwards Arrow Below
    U_Combining_Latin_Small_Letter_A = 867,
    //	U+0363	Combining Latin Small Letter A
    U_Combining_Latin_Small_Letter_E = 868,
    //	U+0364	Combining Latin Small Letter E
    U_Combining_Latin_Small_Letter_I = 869,
    //	U+0365	Combining Latin Small Letter I
    U_Combining_Latin_Small_Letter_O = 870,
    //	U+0366	Combining Latin Small Letter O
    U_Combining_Latin_Small_Letter_U = 871,
    //	U+0367	Combining Latin Small Letter U
    U_Combining_Latin_Small_Letter_C = 872,
    //	U+0368	Combining Latin Small Letter C
    U_Combining_Latin_Small_Letter_D = 873,
    //	U+0369	Combining Latin Small Letter D
    U_Combining_Latin_Small_Letter_H = 874,
    //	U+036A	Combining Latin Small Letter H
    U_Combining_Latin_Small_Letter_M = 875,
    //	U+036B	Combining Latin Small Letter M
    U_Combining_Latin_Small_Letter_R = 876,
    //	U+036C	Combining Latin Small Letter R
    U_Combining_Latin_Small_Letter_T = 877,
    //	U+036D	Combining Latin Small Letter T
    U_Combining_Latin_Small_Letter_V = 878,
    //	U+036E	Combining Latin Small Letter V
    U_Combining_Latin_Small_Letter_X = 879,
    /**
     * Unicode Character 'LINE SEPARATOR' (U+2028)
     * http://www.fileformat.info/info/unicode/char/2028/index.htm
     */
    LINE_SEPARATOR = 8232,
    /**
     * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)
     * http://www.fileformat.info/info/unicode/char/2029/index.htm
     */
    PARAGRAPH_SEPARATOR = 8233,
    /**
     * Unicode Character 'NEXT LINE' (U+0085)
     * http://www.fileformat.info/info/unicode/char/0085/index.htm
     */
    NEXT_LINE = 133,
    // http://www.fileformat.info/info/unicode/category/Sk/list.htm
    U_CIRCUMFLEX = 94,
    // U+005E	CIRCUMFLEX
    U_GRAVE_ACCENT = 96,
    // U+0060	GRAVE ACCENT
    U_DIAERESIS = 168,
    // U+00A8	DIAERESIS
    U_MACRON = 175,
    // U+00AF	MACRON
    U_ACUTE_ACCENT = 180,
    // U+00B4	ACUTE ACCENT
    U_CEDILLA = 184,
    // U+00B8	CEDILLA
    U_MODIFIER_LETTER_LEFT_ARROWHEAD = 706,
    // U+02C2	MODIFIER LETTER LEFT ARROWHEAD
    U_MODIFIER_LETTER_RIGHT_ARROWHEAD = 707,
    // U+02C3	MODIFIER LETTER RIGHT ARROWHEAD
    U_MODIFIER_LETTER_UP_ARROWHEAD = 708,
    // U+02C4	MODIFIER LETTER UP ARROWHEAD
    U_MODIFIER_LETTER_DOWN_ARROWHEAD = 709,
    // U+02C5	MODIFIER LETTER DOWN ARROWHEAD
    U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING = 722,
    // U+02D2	MODIFIER LETTER CENTRED RIGHT HALF RING
    U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING = 723,
    // U+02D3	MODIFIER LETTER CENTRED LEFT HALF RING
    U_MODIFIER_LETTER_UP_TACK = 724,
    // U+02D4	MODIFIER LETTER UP TACK
    U_MODIFIER_LETTER_DOWN_TACK = 725,
    // U+02D5	MODIFIER LETTER DOWN TACK
    U_MODIFIER_LETTER_PLUS_SIGN = 726,
    // U+02D6	MODIFIER LETTER PLUS SIGN
    U_MODIFIER_LETTER_MINUS_SIGN = 727,
    // U+02D7	MODIFIER LETTER MINUS SIGN
    U_BREVE = 728,
    // U+02D8	BREVE
    U_DOT_ABOVE = 729,
    // U+02D9	DOT ABOVE
    U_RING_ABOVE = 730,
    // U+02DA	RING ABOVE
    U_OGONEK = 731,
    // U+02DB	OGONEK
    U_SMALL_TILDE = 732,
    // U+02DC	SMALL TILDE
    U_DOUBLE_ACUTE_ACCENT = 733,
    // U+02DD	DOUBLE ACUTE ACCENT
    U_MODIFIER_LETTER_RHOTIC_HOOK = 734,
    // U+02DE	MODIFIER LETTER RHOTIC HOOK
    U_MODIFIER_LETTER_CROSS_ACCENT = 735,
    // U+02DF	MODIFIER LETTER CROSS ACCENT
    U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR = 741,
    // U+02E5	MODIFIER LETTER EXTRA-HIGH TONE BAR
    U_MODIFIER_LETTER_HIGH_TONE_BAR = 742,
    // U+02E6	MODIFIER LETTER HIGH TONE BAR
    U_MODIFIER_LETTER_MID_TONE_BAR = 743,
    // U+02E7	MODIFIER LETTER MID TONE BAR
    U_MODIFIER_LETTER_LOW_TONE_BAR = 744,
    // U+02E8	MODIFIER LETTER LOW TONE BAR
    U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR = 745,
    // U+02E9	MODIFIER LETTER EXTRA-LOW TONE BAR
    U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK = 746,
    // U+02EA	MODIFIER LETTER YIN DEPARTING TONE MARK
    U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK = 747,
    // U+02EB	MODIFIER LETTER YANG DEPARTING TONE MARK
    U_MODIFIER_LETTER_UNASPIRATED = 749,
    // U+02ED	MODIFIER LETTER UNASPIRATED
    U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD = 751,
    // U+02EF	MODIFIER LETTER LOW DOWN ARROWHEAD
    U_MODIFIER_LETTER_LOW_UP_ARROWHEAD = 752,
    // U+02F0	MODIFIER LETTER LOW UP ARROWHEAD
    U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD = 753,
    // U+02F1	MODIFIER LETTER LOW LEFT ARROWHEAD
    U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD = 754,
    // U+02F2	MODIFIER LETTER LOW RIGHT ARROWHEAD
    U_MODIFIER_LETTER_LOW_RING = 755,
    // U+02F3	MODIFIER LETTER LOW RING
    U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT = 756,
    // U+02F4	MODIFIER LETTER MIDDLE GRAVE ACCENT
    U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT = 757,
    // U+02F5	MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT
    U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT = 758,
    // U+02F6	MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT
    U_MODIFIER_LETTER_LOW_TILDE = 759,
    // U+02F7	MODIFIER LETTER LOW TILDE
    U_MODIFIER_LETTER_RAISED_COLON = 760,
    // U+02F8	MODIFIER LETTER RAISED COLON
    U_MODIFIER_LETTER_BEGIN_HIGH_TONE = 761,
    // U+02F9	MODIFIER LETTER BEGIN HIGH TONE
    U_MODIFIER_LETTER_END_HIGH_TONE = 762,
    // U+02FA	MODIFIER LETTER END HIGH TONE
    U_MODIFIER_LETTER_BEGIN_LOW_TONE = 763,
    // U+02FB	MODIFIER LETTER BEGIN LOW TONE
    U_MODIFIER_LETTER_END_LOW_TONE = 764,
    // U+02FC	MODIFIER LETTER END LOW TONE
    U_MODIFIER_LETTER_SHELF = 765,
    // U+02FD	MODIFIER LETTER SHELF
    U_MODIFIER_LETTER_OPEN_SHELF = 766,
    // U+02FE	MODIFIER LETTER OPEN SHELF
    U_MODIFIER_LETTER_LOW_LEFT_ARROW = 767,
    // U+02FF	MODIFIER LETTER LOW LEFT ARROW
    U_GREEK_LOWER_NUMERAL_SIGN = 885,
    // U+0375	GREEK LOWER NUMERAL SIGN
    U_GREEK_TONOS = 900,
    // U+0384	GREEK TONOS
    U_GREEK_DIALYTIKA_TONOS = 901,
    // U+0385	GREEK DIALYTIKA TONOS
    U_GREEK_KORONIS = 8125,
    // U+1FBD	GREEK KORONIS
    U_GREEK_PSILI = 8127,
    // U+1FBF	GREEK PSILI
    U_GREEK_PERISPOMENI = 8128,
    // U+1FC0	GREEK PERISPOMENI
    U_GREEK_DIALYTIKA_AND_PERISPOMENI = 8129,
    // U+1FC1	GREEK DIALYTIKA AND PERISPOMENI
    U_GREEK_PSILI_AND_VARIA = 8141,
    // U+1FCD	GREEK PSILI AND VARIA
    U_GREEK_PSILI_AND_OXIA = 8142,
    // U+1FCE	GREEK PSILI AND OXIA
    U_GREEK_PSILI_AND_PERISPOMENI = 8143,
    // U+1FCF	GREEK PSILI AND PERISPOMENI
    U_GREEK_DASIA_AND_VARIA = 8157,
    // U+1FDD	GREEK DASIA AND VARIA
    U_GREEK_DASIA_AND_OXIA = 8158,
    // U+1FDE	GREEK DASIA AND OXIA
    U_GREEK_DASIA_AND_PERISPOMENI = 8159,
    // U+1FDF	GREEK DASIA AND PERISPOMENI
    U_GREEK_DIALYTIKA_AND_VARIA = 8173,
    // U+1FED	GREEK DIALYTIKA AND VARIA
    U_GREEK_DIALYTIKA_AND_OXIA = 8174,
    // U+1FEE	GREEK DIALYTIKA AND OXIA
    U_GREEK_VARIA = 8175,
    // U+1FEF	GREEK VARIA
    U_GREEK_OXIA = 8189,
    // U+1FFD	GREEK OXIA
    U_GREEK_DASIA = 8190,
    // U+1FFE	GREEK DASIA
    U_OVERLINE = 8254,
    /**
     * UTF-8 BOM
     * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)
     * http://www.fileformat.info/info/unicode/char/feff/index.htm
     */
    UTF8_BOM = 65279
}
interface ParsedPath {
    root: string;
    dir: string;
    base: string;
    ext: string;
    name: string;
}
interface IPath {
    normalize(path: string): string;
    isAbsolute(path: string): boolean;
    join(...paths: string[]): string;
    resolve(...pathSegments: string[]): string;
    relative(from: string, to: string): string;
    dirname(path: string): string;
    basename(path: string, ext?: string): string;
    extname(path: string): string;
    format(pathObject: ParsedPath): string;
    parse(path: string): ParsedPath;
    toNamespacedPath(path: string): string;
    sep: "\\" | "/";
    delimiter: string;
    win32: IPath | null;
    posix: IPath | null;
}
declare const win32: IPath;
declare const posix: IPath;
declare const normalize: (path: string) => string;
declare const isAbsolute: (path: string) => boolean;
declare const join: (...paths: string[]) => string;
declare const resolve: (...pathSegments: string[]) => string;
declare const relative: (from: string, to: string) => string;
declare const dirname: (path: string) => string;
declare const basename: (path: string, ext?: string) => string;
declare const extname: (path: string) => string;
declare const format: (pathObject: ParsedPath) => string;
declare const parse: (path: string) => ParsedPath;
declare const toNamespacedPath: (path: string) => string;
declare const sep: "\\" | "/";
declare const delimiter: string;
/**
 * Thenable is a common denominator between ES6 promises, Q, jquery.Deferred, WinJS.Promise,
 * and others. This API makes no assumption about what promise libary is being used which
 * enables reusing existing code without migrating to a specific promise implementation. Still,
 * we recommend the use of native promises which are available in VS Code.
 */
interface Thenable<T> {
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => TResult | Thenable<TResult>): Thenable<TResult>;
    then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => void): Thenable<TResult>;
}
export { isThenable, CancelablePromise, createCancelablePromise, raceCancellation, asPromise, Throttler, Sequencer, Delayer, ThrottledDelayer, Barrier, timeout, disposableTimeout, ignoreErrors, sequence, first, Limiter, Queue, retry, CancellationToken, CancellationTokenSource, CharCode, Event, EmitterOptions, setGlobalLeakWarningThreshold, Emitter, PauseableEmitter, IWaitUntil, AsyncEmitter, EventMultiplexer, EventBufferer, Relay, IDisposableTracker, setDisposableTracker, trackDisposable, MultiDisposeError, IDisposable, isDisposable, dispose, combinedDisposable, toDisposable, DisposableStore, Disposable, MutableDisposable, IReference, ReferenceCollection, ImmortalReference, ParsedPath, IPath, win32, posix, normalize, isAbsolute, join, resolve, relative, dirname, basename, extname, format, parse, toNamespacedPath, sep, delimiter, URI, UriComponents, uriToFsPath, Thenable };