@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/events.d.ts

@@ -0,0 +1,138 @@
+declare module "node:events" {
+    import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
+    type EventMap<T> = Record<keyof T, any[]>;
+    type IfEventMap<Events extends EventMap<Events>, True, False> = {} extends Events ? False : True;
+    type Args<Events extends EventMap<Events>, EventName extends string | symbol> = IfEventMap<Events, EventName extends keyof Events ? Events[EventName] : EventName extends keyof EventEmitterEventMap ? EventEmitterEventMap[EventName] : any[], any[]>;
+    type EventNames<Events extends EventMap<Events>, EventName extends string | symbol> = IfEventMap<Events, EventName | (keyof Events & (string | symbol)) | keyof EventEmitterEventMap, string | symbol>;
+    type Listener<Events extends EventMap<Events>, EventName extends string | symbol> = IfEventMap<Events, (...args: EventName extends keyof Events ? Events[EventName] : EventName extends keyof EventEmitterEventMap ? EventEmitterEventMap[EventName] : any[]) => void, (...args: any[]) => void>;
+    interface EventEmitterEventMap {
+        newListener: [
+            eventName: string | symbol,
+            listener: (...args: any[]) => void
+        ];
+        removeListener: [
+            eventName: string | symbol,
+            listener: (...args: any[]) => void
+        ];
+    }
+    interface EventEmitterOptions {
+        captureRejections?: boolean | undefined;
+    }
+    class EventEmitter<T extends EventMap<T> = any> {
+        constructor(options?: EventEmitterOptions);
+    }
+    interface EventEmitter<T extends EventMap<T> = any> extends NodeJS.EventEmitter<T> {
+    }
+    global {
+        namespace NodeJS {
+            interface EventEmitter<T extends EventMap<T> = any> {
+                [EventEmitter.captureRejectionSymbol]?(error: Error, event: string | symbol, ...args: any[]): void;
+                addListener<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                emit<E extends string | symbol>(eventName: EventNames<T, E>, ...args: Args<T, E>): boolean;
+                eventNames(): (string | symbol)[];
+                getMaxListeners(): number;
+                listenerCount<E extends string | symbol>(eventName: EventNames<T, E>, listener?: Listener<T, E>): number;
+                listeners<E extends string | symbol>(eventName: EventNames<T, E>): Listener<T, E>[];
+                off<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                on<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                once<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                prependListener<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                prependOnceListener<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                rawListeners<E extends string | symbol>(eventName: EventNames<T, E>): Listener<T, E>[];
+                removeAllListeners<E extends string | symbol>(eventName?: EventNames<T, E>): this;
+                removeListener<E extends string | symbol>(eventName: EventNames<T, E>, listener: Listener<T, E>): this;
+                setMaxListeners(n: number): this;
+            }
+        }
+    }
+    namespace EventEmitter {
+        export { EventEmitter, EventEmitterEventMap, EventEmitterOptions };
+    }
+    namespace EventEmitter {
+        interface Abortable {
+            signal?: AbortSignal | undefined;
+        }
+        const captureRejectionSymbol: unique symbol;
+        let captureRejections: boolean;
+        let defaultMaxListeners: number;
+        const errorMonitor: unique symbol;
+        function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+        function getEventListeners(emitter: EventEmitter, name: string | symbol): ((...args: any[]) => void)[];
+        function getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
+        function getMaxListeners(emitter: EventEmitter | EventTarget): number;
+        function listenerCount(emitter: EventEmitter, eventName: string | symbol): number;
+        function listenerCount(emitter: EventTarget, eventName: string): number;
+        interface OnOptions extends Abortable {
+            close?: readonly string[] | undefined;
+            highWaterMark?: number | undefined;
+            lowWaterMark?: number | undefined;
+        }
+        function on(emitter: EventEmitter, eventName: string | symbol, options?: OnOptions): NodeJS.AsyncIterator<any[]>;
+        function on(emitter: EventTarget, eventName: string, options?: OnOptions): NodeJS.AsyncIterator<any[]>;
+        interface OnceOptions extends Abortable {
+        }
+        function once(emitter: EventEmitter, eventName: string | symbol, options?: OnceOptions): Promise<any[]>;
+        function once(emitter: EventTarget, eventName: string, options?: OnceOptions): Promise<any[]>;
+        function setMaxListeners(n: number, ...eventTargets: ReadonlyArray<EventEmitter | EventTarget>): void;
+        interface InternalEventEmitter<T extends EventMap<T>> extends EventEmitter {
+            addListener<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof T>(eventName: E, ...args: T[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof T>(eventName: E, listener?: (...args: T[E]) => void): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof T>(eventName: E): ((...args: T[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof T>(eventName: E): ((...args: T[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            removeAllListeners<E extends keyof T>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof T>(eventName: E, listener: (...args: T[E]) => void): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        }
+        interface EventEmitterReferencingAsyncResource extends AsyncResource {
+            readonly eventEmitter: EventEmitterAsyncResource;
+        }
+        interface EventEmitterAsyncResourceOptions extends AsyncResourceOptions, EventEmitterOptions {
+            name?: string | undefined;
+        }
+        class EventEmitterAsyncResource extends EventEmitter {
+            constructor(options?: EventEmitterAsyncResourceOptions);
+            readonly asyncId: number;
+            readonly asyncResource: EventEmitterReferencingAsyncResource;
+            emitDestroy(): void;
+            readonly triggerAsyncId: number;
+        }
+        interface NodeEventTarget extends EventTarget {
+            addListener(type: string, listener: (arg: any) => void): this;
+            emit(type: string, arg: any): boolean;
+            eventNames(): string[];
+            listenerCount(type: string): number;
+            setMaxListeners(n: number): void;
+            getMaxListeners(): number;
+            off(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+            on(type: string, listener: (arg: any) => void): this;
+            once(type: string, listener: (arg: any) => void): this;
+            removeAllListeners(type?: string): this;
+            removeListener(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+        }
+        type InternalEventTargetEventProperties<T> = {
+            [K in keyof T & string as `on${K}`]: ((ev: T[K]) => void) | null;
+        };
+    }
+    export = EventEmitter;
+}
+declare module "events" {
+    import events = require("node:events");
+    export = events;
+}

package/types/node/fs/promises.d.ts

@@ -0,0 +1,253 @@
+declare module "node:fs/promises" {
+    import { NonSharedBuffer } from "node:buffer";
+    import { Abortable } from "node:events";
+    import { Interface as ReadlineInterface } from "node:readline";
+    import { BigIntStats, BigIntStatsFs, BufferEncodingOption, constants as fsConstants, CopyOptions, Dir, Dirent, EncodingOption, GlobOptions, GlobOptionsWithFileTypes, GlobOptionsWithoutFileTypes, MakeDirectoryOptions, Mode, ObjectEncodingOptions, OpenDirOptions, OpenMode, PathLike, ReadOptions, ReadOptionsWithBuffer, ReadPosition, ReadStream, ReadVResult, RmOptions, StatFsOptions, StatOptions, Stats, StatsFs, TimeLike, WatchEventType, WatchOptions as _WatchOptions, WriteStream, WriteVResult, } from "node:fs";
+    import { Stream } from "node:stream";
+    import { ByteReadableStream, Transform, Writer } from "node:stream/iter";
+    import { ReadableStream } from "node:stream/web";
+    interface FileChangeInfo<T extends string | Buffer> {
+        eventType: WatchEventType;
+        filename: T | null;
+    }
+    interface FlagAndOpenMode {
+        mode?: Mode | undefined;
+        flag?: OpenMode | undefined;
+    }
+    interface FileReadResult<T extends NodeJS.ArrayBufferView> {
+        bytesRead: number;
+        buffer: T;
+    }
+    interface FileReadOptions<T extends NodeJS.ArrayBufferView = Buffer> {
+        buffer?: T;
+        offset?: number | null;
+        length?: number | null;
+        position?: ReadPosition | null;
+    }
+    interface CreateReadStreamOptions extends Abortable {
+        encoding?: BufferEncoding | null | undefined;
+        autoClose?: boolean | undefined;
+        emitClose?: boolean | undefined;
+        start?: number | undefined;
+        end?: number | undefined;
+        highWaterMark?: number | undefined;
+    }
+    interface CreateWriteStreamOptions {
+        encoding?: BufferEncoding | null | undefined;
+        autoClose?: boolean | undefined;
+        emitClose?: boolean | undefined;
+        start?: number | undefined;
+        highWaterMark?: number | undefined;
+        flush?: boolean | undefined;
+    }
+    interface ReadableWebStreamOptions {
+        autoClose?: boolean | undefined;
+    }
+    interface PullOptions extends Abortable {
+        autoClose?: boolean | undefined;
+        start?: number | undefined;
+        limit?: number | undefined;
+        chunkSize?: number | undefined;
+    }
+    interface WriterOptions {
+        autoClose?: boolean | undefined;
+        start?: number | undefined;
+        limit?: number | undefined;
+        chunkSize?: number | undefined;
+    }
+    interface FileHandle {
+        readonly fd: number;
+        appendFile(data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView>, options?: (ObjectEncodingOptions & Abortable) | BufferEncoding | null): Promise<void>;
+        chown(uid: number, gid: number): Promise<void>;
+        chmod(mode: Mode): Promise<void>;
+        createReadStream(options?: CreateReadStreamOptions): ReadStream;
+        createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
+        datasync(): Promise<void>;
+        pull(...transforms: Transform[]): ByteReadableStream;
+        pull(...args: [
+            ...transforms: Transform[],
+            options: PullOptions
+        ]): ByteReadableStream;
+        sync(): Promise<void>;
+        read<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number | null, length?: number | null, position?: ReadPosition | null): Promise<FileReadResult<T>>;
+        read<T extends NodeJS.ArrayBufferView>(buffer: T, options?: ReadOptions): Promise<FileReadResult<T>>;
+        read<T extends NodeJS.ArrayBufferView = NonSharedBuffer>(options?: ReadOptionsWithBuffer<T>): Promise<FileReadResult<T>>;
+        readableWebStream(options?: ReadableWebStreamOptions): ReadableStream;
+        readFile(options?: ({
+            encoding?: null | undefined;
+        } & Abortable) | null): Promise<NonSharedBuffer>;
+        readFile(options: ({
+            encoding: BufferEncoding;
+        } & Abortable) | BufferEncoding): Promise<string>;
+        readFile(options?: (ObjectEncodingOptions & Abortable) | BufferEncoding | null): Promise<string | NonSharedBuffer>;
+        readLines(options?: CreateReadStreamOptions): ReadlineInterface;
+        stat(opts?: StatOptions & {
+            bigint?: false | undefined;
+        }): Promise<Stats>;
+        stat(opts: StatOptions & {
+            bigint: true;
+        }): Promise<BigIntStats>;
+        stat(opts?: StatOptions): Promise<Stats | BigIntStats>;
+        truncate(len?: number): Promise<void>;
+        utimes(atime: TimeLike, mtime: TimeLike): Promise<void>;
+        writeFile(data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView>, options?: (ObjectEncodingOptions & Abortable) | BufferEncoding | null): Promise<void>;
+        write<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{
+            bytesWritten: number;
+            buffer: TBuffer;
+        }>;
+        write<TBuffer extends Uint8Array>(buffer: TBuffer, options?: {
+            offset?: number;
+            length?: number;
+            position?: number;
+        }): Promise<{
+            bytesWritten: number;
+            buffer: TBuffer;
+        }>;
+        write(data: string, position?: number | null, encoding?: BufferEncoding | null): Promise<{
+            bytesWritten: number;
+            buffer: string;
+        }>;
+        writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<WriteVResult<TBuffers>>;
+        writer(options?: WriterOptions): Writer;
+        readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<ReadVResult<TBuffers>>;
+        close(): Promise<void>;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    const constants: typeof fsConstants;
+    function access(path: PathLike, mode?: number): Promise<void>;
+    function copyFile(src: PathLike, dest: PathLike, mode?: number): Promise<void>;
+    function open(path: PathLike, flags?: string | number, mode?: Mode): Promise<FileHandle>;
+    function rename(oldPath: PathLike, newPath: PathLike): Promise<void>;
+    function truncate(path: PathLike, len?: number): Promise<void>;
+    function rmdir(path: PathLike): Promise<void>;
+    function rm(path: PathLike, options?: RmOptions): Promise<void>;
+    function mkdir(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    function mkdir(path: PathLike, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): Promise<void>;
+    function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
+    function readdir(path: PathLike, options?: (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<string[]>;
+    function readdir(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | "buffer"): Promise<NonSharedBuffer[]>;
+    function readdir(path: PathLike, options?: (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<string[] | NonSharedBuffer[]>;
+    function readdir(path: PathLike, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<Dirent[]>;
+    function readdir(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<Dirent<NonSharedBuffer>[]>;
+    function readlink(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    function readlink(path: PathLike, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+    function readlink(path: PathLike, options?: ObjectEncodingOptions | string | null): Promise<string | NonSharedBuffer>;
+    function symlink(target: PathLike, path: PathLike, type?: string | null): Promise<void>;
+    function lstat(path: PathLike, opts?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<Stats>;
+    function lstat(path: PathLike, opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    function lstat(path: PathLike, opts?: StatOptions): Promise<Stats | BigIntStats>;
+    function stat(path: PathLike): Promise<Stats>;
+    function stat(path: PathLike, opts?: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry?: true | undefined;
+    }): Promise<Stats>;
+    function stat(path: PathLike, opts: StatOptions & {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): Promise<BigIntStats>;
+    function stat(path: PathLike, opts: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Promise<Stats | undefined>;
+    function stat(path: PathLike, opts: StatOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): Promise<BigIntStats | undefined>;
+    function stat(path: PathLike, opts: StatOptions & {
+        throwIfNoEntry?: true | undefined;
+    }): Promise<Stats | BigIntStats>;
+    function stat(path: PathLike, opts?: StatOptions): Promise<Stats | BigIntStats | undefined>;
+    function statfs(path: PathLike, opts?: StatFsOptions & {
+        bigint?: false | undefined;
+    }): Promise<StatsFs>;
+    function statfs(path: PathLike, opts: StatFsOptions & {
+        bigint: true;
+    }): Promise<BigIntStatsFs>;
+    function statfs(path: PathLike, opts?: StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+    function link(existingPath: PathLike, newPath: PathLike): Promise<void>;
+    function unlink(path: PathLike): Promise<void>;
+    function chmod(path: PathLike, mode: Mode): Promise<void>;
+    function lchmod(path: PathLike, mode: Mode): Promise<void>;
+    function lchown(path: PathLike, uid: number, gid: number): Promise<void>;
+    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+    function chown(path: PathLike, uid: number, gid: number): Promise<void>;
+    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+    function realpath(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    function realpath(path: PathLike, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+    function realpath(path: PathLike, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | NonSharedBuffer>;
+    function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+    function mkdtemp(prefix: string, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+    function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | NonSharedBuffer>;
+    interface DisposableTempDir extends AsyncDisposable {
+        path: string;
+        remove(): Promise<void>;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    function mkdtempDisposable(prefix: PathLike, options?: EncodingOption): Promise<DisposableTempDir>;
+    function writeFile(file: PathLike | FileHandle, data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView>, options?: (ObjectEncodingOptions & {
+        mode?: Mode | undefined;
+        flag?: OpenMode | undefined;
+        flush?: boolean | undefined;
+    } & Abortable) | BufferEncoding | null): Promise<void>;
+    function appendFile(path: PathLike | FileHandle, data: string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView>, options?: (ObjectEncodingOptions & FlagAndOpenMode & {
+        flush?: boolean | undefined;
+    }) | BufferEncoding | null): Promise<void>;
+    function readFile(path: PathLike | FileHandle, options?: ({
+        encoding?: null | undefined;
+        flag?: OpenMode | undefined;
+    } & Abortable) | null): Promise<NonSharedBuffer>;
+    function readFile(path: PathLike | FileHandle, options: ({
+        encoding: BufferEncoding;
+        flag?: OpenMode | undefined;
+    } & Abortable) | BufferEncoding): Promise<string>;
+    function readFile(path: PathLike | FileHandle, options?: (ObjectEncodingOptions & Abortable & {
+        flag?: OpenMode | undefined;
+    }) | BufferEncoding | null): Promise<string | NonSharedBuffer>;
+    function opendir(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
+    interface WatchOptions extends _WatchOptions {
+        maxQueue?: number | undefined;
+        overflow?: "ignore" | "throw" | undefined;
+    }
+    interface WatchOptionsWithBufferEncoding extends WatchOptions {
+        encoding: "buffer";
+    }
+    interface WatchOptionsWithStringEncoding extends WatchOptions {
+        encoding?: BufferEncoding | undefined;
+    }
+    function watch(filename: PathLike, options?: WatchOptionsWithStringEncoding | BufferEncoding): NodeJS.AsyncIterator<FileChangeInfo<string>>;
+    function watch(filename: PathLike, options: WatchOptionsWithBufferEncoding | "buffer"): NodeJS.AsyncIterator<FileChangeInfo<NonSharedBuffer>>;
+    function watch(filename: PathLike, options: WatchOptions | BufferEncoding | "buffer"): NodeJS.AsyncIterator<FileChangeInfo<string | NonSharedBuffer>>;
+    function cp(source: string | URL, destination: string | URL, opts?: CopyOptions): Promise<void>;
+    function glob(pattern: string | readonly string[]): NodeJS.AsyncIterator<string>;
+    function glob(pattern: string | readonly string[], options: GlobOptionsWithFileTypes): NodeJS.AsyncIterator<Dirent>;
+    function glob(pattern: string | readonly string[], options: GlobOptionsWithoutFileTypes): NodeJS.AsyncIterator<string>;
+    function glob(pattern: string | readonly string[], options: GlobOptions): NodeJS.AsyncIterator<Dirent | string>;
+}
+declare module "fs/promises" {
+    export * from "node:fs/promises";
+}