@scelar/nodepod 1.0.1 → 1.0.2

package/dist/packages/version-resolver.d.ts

@@ -0,0 +1,37 @@
+import { RegistryClient } from "./registry-client";
+export interface ResolvedDependency {
+    name: string;
+    version: string;
+    tarballUrl: string;
+    dependencies: Record<string, string>;
+}
+export interface ResolutionConfig {
+    registry?: RegistryClient;
+    devDependencies?: boolean;
+    optionalDependencies?: boolean;
+    onProgress?: (msg: string) => void;
+}
+export interface SemverComponents {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+}
+export declare function parseSemver(raw: string): SemverComponents | null;
+export declare function compareSemver(left: string, right: string): number;
+export declare function satisfiesRange(version: string, range: string): boolean;
+export declare function pickBestMatch(available: string[], range: string): string | null;
+export declare function resolveDependencyTree(rootName: string, versionRange?: string, config?: ResolutionConfig): Promise<Map<string, ResolvedDependency>>;
+export declare function resolveFromManifest(manifest: {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}, config?: ResolutionConfig): Promise<Map<string, ResolvedDependency>>;
+export declare class VersionResolver {
+    parse: typeof parseSemver;
+    compare: typeof compareSemver;
+    satisfies: typeof satisfiesRange;
+    pickBest: typeof pickBestMatch;
+    resolveTree: typeof resolveDependencyTree;
+    resolveManifest: typeof resolveFromManifest;
+}
+export default VersionResolver;

package/dist/polyfills/assert.d.ts

@@ -0,0 +1,54 @@
+export interface AssertionError extends Error {
+    actual: unknown;
+    expected: unknown;
+    operator: string;
+    generatedMessage: boolean;
+    code: string;
+}
+interface AssertionErrorConstructor {
+    new (info: {
+        message?: string;
+        actual?: unknown;
+        expected?: unknown;
+        operator?: string;
+        stackStartFn?: Function;
+    }): AssertionError;
+    (this: any, info: {
+        message?: string;
+        actual?: unknown;
+        expected?: unknown;
+        operator?: string;
+        stackStartFn?: Function;
+    }): void;
+    prototype: any;
+}
+export declare const AssertionError: AssertionErrorConstructor;
+declare function assert(value: unknown, message?: string | Error): asserts value;
+declare namespace assert {
+    var ok: (value: unknown, message?: string | Error) => asserts value;
+    var equal: (actual: unknown, expected: unknown, message?: string | Error) => void;
+    var notEqual: (actual: unknown, expected: unknown, message?: string | Error) => void;
+    var strictEqual: (actual: unknown, expected: unknown, message?: string | Error) => void;
+    var notStrictEqual: (actual: unknown, expected: unknown, message?: string | Error) => void;
+    var deepEqual: <T>(actual: T, expected: T, message?: string | Error) => void;
+    var deepStrictEqual: <T>(actual: T, expected: T, message?: string | Error) => void;
+    var notDeepStrictEqual: <T>(actual: T, expected: T, message?: string | Error) => void;
+    var throws: (fn: () => unknown, validatorOrMsg?: RegExp | Function | Error | {
+        message?: RegExp | string;
+        code?: string;
+    } | string, msg?: string) => void;
+    var doesNotThrow: (fn: () => unknown, validatorOrMsg?: RegExp | Function | string, msg?: string) => void;
+    var rejects: (asyncFn: Promise<unknown> | (() => Promise<unknown>), validatorOrMsg?: RegExp | Function | Error | {
+        message?: RegExp | string;
+        code?: string;
+    } | string, msg?: string) => Promise<void>;
+    var doesNotReject: (asyncFn: Promise<unknown> | (() => Promise<unknown>), validatorOrMsg?: RegExp | Function | string, msg?: string) => Promise<void>;
+    var fail: (msgOrActual?: string | unknown, expected?: unknown, message?: string, operator?: string) => never;
+    var match: (str: string, re: RegExp, message?: string | Error) => void;
+    var doesNotMatch: (str: string, re: RegExp, message?: string | Error) => void;
+    var ifError: (value: unknown) => void;
+    var AssertionError: AssertionErrorConstructor;
+    var strict: typeof assert;
+}
+export default assert;
+export { assert };

package/dist/polyfills/async_hooks.d.ts

@@ -0,0 +1,46 @@
+export interface AsyncResource {
+    runInAsyncScope<R>(fn: (...a: any[]) => R, thisArg?: unknown, ...args: any[]): R;
+    emitDestroy(): this;
+    asyncId(): number;
+    triggerAsyncId(): number;
+}
+export declare const AsyncResource: {
+    new (_kind: string, _opts?: object): AsyncResource;
+    prototype: any;
+    bind<F extends (...a: any[]) => any>(fn: F, _kind?: string): F;
+};
+export interface AsyncLocalStorage<T> {
+    disable(): void;
+    getStore(): T | undefined;
+    run<R>(store: T, fn: (...args: any[]) => R, ...args: any[]): R;
+    exit<R>(fn: (...args: any[]) => R, ...args: any[]): R;
+    enterWith(store: T): void;
+}
+export declare const AsyncLocalStorage: {
+    new <T>(): AsyncLocalStorage<T>;
+    prototype: any;
+};
+export interface AsyncHook {
+    enable(): AsyncHook;
+    disable(): AsyncHook;
+}
+export declare function createHook(_callbacks: object): AsyncHook;
+export declare function executionAsyncId(): number;
+export declare function executionAsyncResource(): object;
+export declare function triggerAsyncId(): number;
+declare const _default: {
+    AsyncResource: {
+        new (_kind: string, _opts?: object): AsyncResource;
+        prototype: any;
+        bind<F extends (...a: any[]) => any>(fn: F, _kind?: string): F;
+    };
+    AsyncLocalStorage: {
+        new <T>(): AsyncLocalStorage<T>;
+        prototype: any;
+    };
+    createHook: typeof createHook;
+    executionAsyncId: typeof executionAsyncId;
+    executionAsyncResource: typeof executionAsyncResource;
+    triggerAsyncId: typeof triggerAsyncId;
+};
+export default _default;

package/dist/polyfills/buffer.d.ts

@@ -0,0 +1,111 @@
+declare class BufferPolyfill extends Uint8Array {
+    static readonly BYTES_PER_ELEMENT = 1;
+    static from(source: ArrayLike<number>): BufferPolyfill;
+    static from<T>(source: ArrayLike<T>, mapper: (v: T, i: number) => number, ctx?: unknown): BufferPolyfill;
+    static from(source: string, enc?: string): BufferPolyfill;
+    static from(source: ArrayBuffer | Uint8Array): BufferPolyfill;
+    static from(source: Iterable<number>): BufferPolyfill;
+    static alloc(len: number, fillValue?: number): BufferPolyfill;
+    static allocUnsafe(len: number): BufferPolyfill;
+    static allocUnsafeSlow(len: number): BufferPolyfill;
+    static concat(list: (Uint8Array | BufferPolyfill)[]): BufferPolyfill;
+    static isBuffer(candidate: unknown): candidate is BufferPolyfill;
+    static isEncoding(enc: string): boolean;
+    static byteLength(text: string, enc?: string): number;
+    toString(enc?: BufferEncoding): string;
+    slice(begin?: number, end?: number): BufferPolyfill;
+    subarray(begin?: number, end?: number): BufferPolyfill;
+    write(string: string, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, encoding?: BufferEncoding): number;
+    write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
+    copy(dest: BufferPolyfill, destStart?: number, srcStart?: number, srcEnd?: number): number;
+    compare(other: Uint8Array): number;
+    equals(other: Uint8Array): boolean;
+    toJSON(): {
+        type: string;
+        data: number[];
+    };
+    hasOwnProperty(key: PropertyKey): boolean;
+    indexOf(needle: number | Uint8Array | string, fromIndex?: number): number;
+    includes(needle: number | Uint8Array | string, fromIndex?: number): boolean;
+    readUInt8(pos: number): number;
+    readUInt16BE(pos: number): number;
+    readUInt16LE(pos: number): number;
+    readUInt32BE(pos: number): number;
+    readUInt32LE(pos: number): number;
+    writeUInt8(val: number, pos: number): number;
+    writeUInt16BE(val: number, pos: number): number;
+    writeUInt16LE(val: number, pos: number): number;
+    writeUInt32BE(val: number, pos: number): number;
+    writeUInt32LE(val: number, pos: number): number;
+    readUint8(pos: number): number;
+    readUint16BE(pos: number): number;
+    readUint16LE(pos: number): number;
+    readUint32BE(pos: number): number;
+    readUint32LE(pos: number): number;
+    writeUint8(val: number, pos: number): number;
+    writeUint16BE(val: number, pos: number): number;
+    writeUint16LE(val: number, pos: number): number;
+    writeUint32BE(val: number, pos: number): number;
+    writeUint32LE(val: number, pos: number): number;
+    readInt8(pos: number): number;
+    readInt16BE(pos: number): number;
+    readInt16LE(pos: number): number;
+    readInt32BE(pos: number): number;
+    readInt32LE(pos: number): number;
+    writeInt8(val: number, pos: number): number;
+    writeInt16BE(val: number, pos: number): number;
+    writeInt16LE(val: number, pos: number): number;
+    writeInt32BE(val: number, pos: number): number;
+    writeInt32LE(val: number, pos: number): number;
+    readBigUInt64LE(pos: number): bigint;
+    readBigUInt64BE(pos: number): bigint;
+    readBigInt64LE(pos: number): bigint;
+    readBigInt64BE(pos: number): bigint;
+    writeBigUInt64LE(val: bigint, pos: number): number;
+    writeBigUInt64BE(val: bigint, pos: number): number;
+    writeBigInt64LE(val: bigint, pos: number): number;
+    writeBigInt64BE(val: bigint, pos: number): number;
+    readBigUint64LE(pos: number): bigint;
+    readBigUint64BE(pos: number): bigint;
+    writeBigUint64LE(val: bigint, pos: number): number;
+    writeBigUint64BE(val: bigint, pos: number): number;
+    readFloatLE(pos: number): number;
+    readFloatBE(pos: number): number;
+    readDoubleLE(pos: number): number;
+    readDoubleBE(pos: number): number;
+    writeFloatLE(val: number, pos: number): number;
+    writeFloatBE(val: number, pos: number): number;
+    writeDoubleLE(val: number, pos: number): number;
+    writeDoubleBE(val: number, pos: number): number;
+    readUIntLE(pos: number, width: number): number;
+    readUintLE(pos: number, width: number): number;
+    readUIntBE(pos: number, width: number): number;
+    readUintBE(pos: number, width: number): number;
+    readIntLE(pos: number, width: number): number;
+    readIntBE(pos: number, width: number): number;
+    writeUIntLE(val: number, pos: number, width: number): number;
+    writeUintLE(val: number, pos: number, width: number): number;
+    writeUIntBE(val: number, pos: number, width: number): number;
+    writeUintBE(val: number, pos: number, width: number): number;
+    writeIntLE(val: number, pos: number, width: number): number;
+    writeIntBE(val: number, pos: number, width: number): number;
+    swap16(): this;
+    swap32(): this;
+    swap64(): this;
+}
+declare const Buffer: BufferConstructor & typeof BufferPolyfill;
+export { Buffer };
+export declare const SlowBuffer: BufferConstructor & typeof BufferPolyfill;
+export declare const kMaxLength = 2147483647;
+export declare const INSPECT_MAX_BYTES = 50;
+export declare const constants: {
+    MAX_LENGTH: number;
+    MAX_STRING_LENGTH: number;
+};
+export declare function transcode(src: Uint8Array, _fromEnc: string, _toEnc: string): InstanceType<typeof BufferPolyfill>;
+export declare function resolveObjectURL(_id: string): undefined;
+export declare function atob(data: string): string;
+export declare function btoa(data: string): string;
+declare const bufferModule: Record<string, unknown>;
+export default bufferModule;

package/dist/polyfills/child_process.d.ts

@@ -0,0 +1,141 @@
+import type { ShellResult, ShellContext } from "../shell/shell-types";
+import { EventEmitter } from "./events";
+import { Readable, Writable } from "./stream";
+import type { MemoryVolume } from "../memory-volume";
+import type { SyncChannelWorker } from "../threading/sync-channel";
+export declare function setStreamingCallbacks(cfg: {
+    onStdout?: (t: string) => void;
+    onStderr?: (t: string) => void;
+    signal?: AbortSignal;
+    getCols?: () => number;
+    getRows?: () => number;
+    onRawModeChange?: (isRaw: boolean) => void;
+}): void;
+export declare function clearStreamingCallbacks(): void;
+export declare function setSyncChannel(channel: SyncChannelWorker): void;
+export type SpawnChildCallback = (command: string, args: string[], opts?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdio?: "pipe" | "inherit";
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+}) => Promise<{
+    pid: number;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function setSpawnChildCallback(fn: SpawnChildCallback): void;
+export type ForkChildCallback = (modulePath: string, args: string[], opts: {
+    cwd: string;
+    env: Record<string, string>;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    onIPC?: (data: unknown) => void;
+    onExit?: (exitCode: number) => void;
+}) => {
+    sendIPC: (data: unknown) => void;
+    disconnect: () => void;
+    requestId: number;
+};
+export declare function setForkChildCallback(fn: ForkChildCallback): void;
+export declare function setIPCSend(fn: (data: unknown) => void): void;
+export declare function setIPCReceiveHandler(fn: (data: unknown) => void): void;
+export declare function handleIPCFromParent(data: unknown): void;
+export declare function getShellCwd(): string;
+export declare function setShellCwd(dir: string): void;
+export declare function shellExec(cmd: string, opts: {
+    cwd?: string;
+    env?: Record<string, string>;
+}, callback: (error: Error | null, stdout: string, stderr: string) => void): void;
+export declare function isStdinRaw(): boolean;
+export declare function sendStdin(text: string): void;
+export declare function initShellExec(volume: MemoryVolume, opts?: {
+    cwd?: string;
+    env?: Record<string, string>;
+}): void;
+export declare function executeNodeBinary(filePath: string, args: string[], ctx: ShellContext, opts?: {
+    isFork?: boolean;
+    workerThreadsOverride?: {
+        isMainThread: boolean;
+        parentPort: unknown;
+        workerData: unknown;
+        threadId: number;
+    };
+}): Promise<ShellResult>;
+export interface RunOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    encoding?: BufferEncoding | "buffer";
+    timeout?: number;
+    maxBuffer?: number;
+    shell?: string | boolean;
+}
+export type RunCallback = (err: Error | null, stdout: string | Buffer, stderr: string | Buffer) => void;
+export interface SpawnConfig {
+    cwd?: string;
+    env?: Record<string, string>;
+    shell?: boolean | string;
+    stdio?: "pipe" | "inherit" | "ignore" | Array<"pipe" | "inherit" | "ignore">;
+}
+export declare function exec(command: string, optsOrCb?: RunOptions | RunCallback, cb?: RunCallback): ShellProcess;
+export declare function execSync(cmd: string, opts?: RunOptions): string | Buffer;
+export declare function spawn(command: string, argsOrOpts?: string[] | SpawnConfig, opts?: SpawnConfig): ShellProcess;
+export declare function spawnSync(cmd: string, args?: string[] | SpawnConfig, opts?: SpawnConfig): {
+    stdout: Buffer;
+    stderr: Buffer;
+    status: number;
+    signal: null;
+    pid: number;
+    output: [null, Buffer, Buffer];
+    error?: Error;
+};
+export declare function execFileSync(file: string, args?: string[], opts?: RunOptions): string | Buffer;
+export declare function execFile(file: string, argsOrOpts?: string[] | RunOptions | RunCallback, optsOrCb?: RunOptions | RunCallback, cb?: RunCallback): ShellProcess;
+export declare function fork(modulePath: string, argsOrOpts?: string[] | Record<string, unknown>, opts?: Record<string, unknown>): ShellProcess;
+export interface ShellProcess extends EventEmitter {
+    pid: number;
+    connected: boolean;
+    killed: boolean;
+    exitCode: number | null;
+    signalCode: string | null;
+    spawnargs: string[];
+    spawnfile: string;
+    stdin: Writable | null;
+    stdout: Readable | null;
+    stderr: Readable | null;
+    kill(sig?: string): boolean;
+    disconnect(): void;
+    send(msg: unknown, cb?: (e: Error | null) => void): boolean;
+    ref(): this;
+    unref(): this;
+}
+interface ShellProcessConstructor {
+    new (): ShellProcess;
+    (this: any): void;
+    prototype: any;
+}
+export declare const ShellProcess: ShellProcessConstructor;
+declare const _default: {
+    exec: typeof exec;
+    execSync: typeof execSync;
+    execFile: typeof execFile;
+    execFileSync: typeof execFileSync;
+    spawn: typeof spawn;
+    spawnSync: typeof spawnSync;
+    fork: typeof fork;
+    ShellProcess: ShellProcessConstructor;
+    initShellExec: typeof initShellExec;
+    shellExec: typeof shellExec;
+    setStreamingCallbacks: typeof setStreamingCallbacks;
+    clearStreamingCallbacks: typeof clearStreamingCallbacks;
+    sendStdin: typeof sendStdin;
+    setSyncChannel: typeof setSyncChannel;
+    setSpawnChildCallback: typeof setSpawnChildCallback;
+    setForkChildCallback: typeof setForkChildCallback;
+    setIPCSend: typeof setIPCSend;
+    setIPCReceiveHandler: typeof setIPCReceiveHandler;
+    handleIPCFromParent: typeof handleIPCFromParent;
+    executeNodeBinary: typeof executeNodeBinary;
+};
+export default _default;

package/dist/polyfills/chokidar.d.ts

@@ -0,0 +1,63 @@
+import type { MemoryVolume, FileWatchHandle } from "../memory-volume";
+export declare function setVolume(vol: MemoryVolume): void;
+type Listener = (...args: unknown[]) => void;
+interface MiniEmitter {
+    handlers: Map<string, Set<Listener>>;
+    on(name: string, fn: Listener): this;
+    off(name: string, fn: Listener): this;
+    fire(name: string, ...args: unknown[]): void;
+}
+interface MiniEmitterConstructor {
+    new (): MiniEmitter;
+    (this: any): void;
+    prototype: any;
+}
+declare const MiniEmitter: MiniEmitterConstructor;
+export interface WatcherConfig {
+    persistent?: boolean;
+    ignored?: string | RegExp | ((p: string) => boolean) | Array<string | RegExp | ((p: string) => boolean)>;
+    ignoreInitial?: boolean;
+    followSymlinks?: boolean;
+    cwd?: string;
+    disableGlobbing?: boolean;
+    usePolling?: boolean;
+    interval?: number;
+    binaryInterval?: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    awaitWriteFinish?: boolean | {
+        stabilityThreshold?: number;
+        pollInterval?: number;
+    };
+    ignorePermissionErrors?: boolean;
+    atomic?: boolean | number;
+}
+export interface PathWatcher extends MiniEmitter {
+    vol: MemoryVolume;
+    cfg: WatcherConfig;
+    handles: Map<string, FileWatchHandle>;
+    terminated: boolean;
+    initialised: boolean;
+    add(targets: string | readonly string[]): this;
+    unwatch(targets: string | readonly string[]): this;
+    close(): Promise<void>;
+    getWatched(): Record<string, string[]>;
+    resolvePath(raw: string): string;
+    isExcluded(target: string): boolean;
+    gatherInitial(dir: string, queue: Array<() => void>): void;
+    attachWatcher(target: string, filterFor?: string): void;
+    watchSubtree(dir: string, level?: number): void;
+}
+interface PathWatcherConstructor {
+    new (cfg?: WatcherConfig): PathWatcher;
+    (this: any, cfg?: WatcherConfig): void;
+    prototype: any;
+}
+export declare const PathWatcher: PathWatcherConstructor;
+export declare function watch(targets: string | readonly string[], options?: WatcherConfig): PathWatcher;
+declare const _default: {
+    watch: typeof watch;
+    PathWatcher: PathWatcherConstructor;
+    setVolume: typeof setVolume;
+};
+export default _default;

package/dist/polyfills/cluster.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from "./events";
+export declare const isMaster = true;
+export declare const isPrimary = true;
+export declare const isWorker = false;
+export interface Worker extends EventEmitter {
+    id: number;
+    process: null;
+    send(_msg: unknown, _cb?: (err: Error | null) => void): boolean;
+    kill(_sig?: string): void;
+    disconnect(): void;
+    isDead(): boolean;
+    isConnected(): boolean;
+}
+export declare const Worker: {
+    new (): Worker;
+    prototype: any;
+};
+export declare const worker: Worker | null;
+export declare const workers: Record<number, Worker>;
+export declare const settings: Record<string, unknown>;
+export declare const SCHED_NONE = 1;
+export declare const SCHED_RR = 2;
+export declare let schedulingPolicy: number;
+export declare function fork(_env?: object): Worker;
+export declare function disconnect(done?: () => void): void;
+export declare function setupMaster(_cfg?: object): void;
+export declare function setupPrimary(_cfg?: object): void;
+export declare const on: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+export declare const once: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+export declare const emit: (name: string, ...payload: unknown[]) => boolean;
+export declare const removeListener: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+declare const _default: {
+    isMaster: boolean;
+    isPrimary: boolean;
+    isWorker: boolean;
+    Worker: {
+        new (): Worker;
+        prototype: any;
+    };
+    worker: null;
+    workers: Record<number, Worker>;
+    fork: typeof fork;
+    disconnect: typeof disconnect;
+    settings: Record<string, unknown>;
+    SCHED_NONE: number;
+    SCHED_RR: number;
+    schedulingPolicy: number;
+    setupMaster: typeof setupMaster;
+    setupPrimary: typeof setupPrimary;
+    on: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+    once: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+    emit: (name: string, ...payload: unknown[]) => boolean;
+    removeListener: (name: string, handler: import("./events").EventHandler) => EventEmitter;
+};
+export default _default;

package/dist/polyfills/console.d.ts

@@ -0,0 +1,72 @@
+export interface Console {
+    _out: {
+        write: (s: string) => void;
+    } | null;
+    _err: {
+        write: (s: string) => void;
+    } | null;
+    _emit(target: "out" | "err", args: unknown[]): void;
+    log(...a: unknown[]): void;
+    error(...a: unknown[]): void;
+    warn(...a: unknown[]): void;
+    info(...a: unknown[]): void;
+    debug(...a: unknown[]): void;
+    trace(...a: unknown[]): void;
+    dir(o: unknown): void;
+    time(): void;
+    timeEnd(): void;
+    timeLog(): void;
+    assert(v: unknown, ...a: unknown[]): void;
+    clear(): void;
+    count(): void;
+    countReset(): void;
+    group(): void;
+    groupCollapsed(): void;
+    groupEnd(): void;
+    table(d: unknown): void;
+}
+interface ConsoleConstructor {
+    new (stdout?: unknown, stderr?: unknown): Console;
+    (this: any, stdout?: unknown, stderr?: unknown): void;
+    prototype: any;
+}
+export declare const Console: ConsoleConstructor;
+export declare const log: (...data: any[]) => void;
+export declare const error: (...data: any[]) => void;
+export declare const warn: (...data: any[]) => void;
+export declare const info: (...data: any[]) => void;
+export declare const debug: (...data: any[]) => void;
+export declare const trace: (...data: any[]) => void;
+export declare const dir: (item?: any, options?: any) => void;
+export declare const time: (label?: string) => void;
+export declare const timeEnd: (label?: string) => void;
+export declare const timeLog: (label?: string, ...data: any[]) => void;
+export declare const clear: () => void;
+export declare const count: (label?: string) => void;
+export declare const countReset: (label?: string) => void;
+export declare const group: (...data: any[]) => void;
+export declare const groupCollapsed: (...data: any[]) => void;
+export declare const groupEnd: () => void;
+export declare const table: (tabularData?: any, properties?: string[]) => void;
+declare const _default: {
+    Console: ConsoleConstructor;
+    log: (...data: any[]) => void;
+    error: (...data: any[]) => void;
+    warn: (...data: any[]) => void;
+    info: (...data: any[]) => void;
+    debug: (...data: any[]) => void;
+    trace: (...data: any[]) => void;
+    dir: (item?: any, options?: any) => void;
+    time: (label?: string) => void;
+    timeEnd: (label?: string) => void;
+    timeLog: (label?: string, ...data: any[]) => void;
+    assert: (condition?: boolean, ...data: any[]) => void;
+    clear: () => void;
+    count: (label?: string) => void;
+    countReset: (label?: string) => void;
+    group: (...data: any[]) => void;
+    groupCollapsed: (...data: any[]) => void;
+    groupEnd: () => void;
+    table: (tabularData?: any, properties?: string[]) => void;
+};
+export default _default;