@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/tty.d.ts

@@ -0,0 +1,61 @@
+declare module "node:tty" {
+    import * as net from "node:net";
+    function isatty(fd: number): boolean;
+    class ReadStream extends net.Socket {
+        constructor(fd: number, options?: net.SocketConstructorOpts);
+        isRaw: boolean;
+        setRawMode(mode: boolean): this;
+        isTTY: boolean;
+    }
+    type Direction = -1 | 0 | 1;
+    interface WriteStreamEventMap extends net.SocketEventMap {
+        "resize": [
+        ];
+    }
+    class WriteStream extends net.Socket {
+        constructor(fd: number);
+        clearLine(dir: Direction, callback?: () => void): boolean;
+        clearScreenDown(callback?: () => void): boolean;
+        cursorTo(x: number, y?: number, callback?: () => void): boolean;
+        cursorTo(x: number, callback: () => void): boolean;
+        moveCursor(dx: number, dy: number, callback?: () => void): boolean;
+        getColorDepth(env?: object): number;
+        hasColors(count?: number): boolean;
+        hasColors(env?: object): boolean;
+        hasColors(count: number, env?: object): boolean;
+        getWindowSize(): [
+            number,
+            number
+        ];
+        columns: number;
+        rows: number;
+        isTTY: boolean;
+        addListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof WriteStreamEventMap>(eventName: E, ...args: WriteStreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof WriteStreamEventMap>(eventName: E, listener?: (...args: WriteStreamEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof WriteStreamEventMap>(eventName: E): ((...args: WriteStreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof WriteStreamEventMap>(eventName: E): ((...args: WriteStreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof WriteStreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+}
+declare module "tty" {
+    export * from "node:tty";
+}

package/types/node/url.d.ts

@@ -0,0 +1,165 @@
+declare module "node:url" {
+    import { Blob, NonSharedBuffer } from "node:buffer";
+    import { ClientRequestArgs } from "node:http";
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from "node:querystring";
+    interface UrlObject {
+        auth?: string | null | undefined;
+        hash?: string | null | undefined;
+        host?: string | null | undefined;
+        hostname?: string | null | undefined;
+        href?: string | null | undefined;
+        pathname?: string | null | undefined;
+        protocol?: string | null | undefined;
+        search?: string | null | undefined;
+        slashes?: boolean | null | undefined;
+        port?: string | number | null | undefined;
+        query?: string | null | ParsedUrlQueryInput | undefined;
+    }
+    interface Url {
+        auth: string | null;
+        hash: string | null;
+        host: string | null;
+        hostname: string | null;
+        href: string;
+        path: string | null;
+        pathname: string | null;
+        protocol: string | null;
+        search: string | null;
+        slashes: boolean | null;
+        port: string | null;
+        query: string | null | ParsedUrlQuery;
+    }
+    interface UrlWithParsedQuery extends Url {
+        query: ParsedUrlQuery;
+    }
+    interface UrlWithStringQuery extends Url {
+        query: string | null;
+    }
+    interface FileUrlToPathOptions {
+        windows?: boolean | undefined;
+    }
+    interface PathToFileUrlOptions {
+        windows?: boolean | undefined;
+    }
+    function parse(urlString: string, parseQueryString?: false, slashesDenoteHost?: boolean): UrlWithStringQuery;
+    function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
+    function parse(urlString: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
+    function format(urlObject: URL, options?: URLFormatOptions): string;
+    function format(urlObject: UrlObject): string;
+    function format(urlString: string): string;
+    function resolve(from: string, to: string): string;
+    function domainToASCII(domain: string): string;
+    function domainToUnicode(domain: string): string;
+    function fileURLToPath(url: string | URL, options?: FileUrlToPathOptions): string;
+    function fileURLToPathBuffer(url: string | URL, options?: FileUrlToPathOptions): NonSharedBuffer;
+    function pathToFileURL(path: string, options?: PathToFileUrlOptions): URL;
+    function urlToHttpOptions(url: URL): ClientRequestArgs;
+    interface URLFormatOptions {
+        auth?: boolean | undefined;
+        fragment?: boolean | undefined;
+        search?: boolean | undefined;
+        unicode?: boolean | undefined;
+    }
+    type URLPatternInput = string | URLPatternInit;
+    interface URLPatternComponentResult {
+        input: string;
+        groups: Record<string, string | undefined>;
+    }
+    interface URLPatternInit {
+        protocol?: string;
+        username?: string;
+        password?: string;
+        hostname?: string;
+        port?: string;
+        pathname?: string;
+        search?: string;
+        hash?: string;
+        baseURL?: string;
+    }
+    interface URLPatternOptions {
+        ignoreCase?: boolean;
+    }
+    interface URLPatternResult {
+        inputs: URLPatternInput[];
+        protocol: URLPatternComponentResult;
+        username: URLPatternComponentResult;
+        password: URLPatternComponentResult;
+        hostname: URLPatternComponentResult;
+        port: URLPatternComponentResult;
+        pathname: URLPatternComponentResult;
+        search: URLPatternComponentResult;
+        hash: URLPatternComponentResult;
+    }
+    interface URL {
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: URLSearchParams;
+        username: string;
+        toJSON(): string;
+    }
+    var URL: {
+        prototype: URL;
+        new (url: string | URL, base?: string | URL): URL;
+        canParse(input: string | URL, base?: string | URL): boolean;
+        createObjectURL(blob: Blob): string;
+        parse(input: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(id: string): void;
+    };
+    interface URLPattern {
+        readonly hasRegExpGroups: boolean;
+        readonly hash: string;
+        readonly hostname: string;
+        readonly password: string;
+        readonly pathname: string;
+        readonly port: string;
+        readonly protocol: string;
+        readonly search: string;
+        readonly username: string;
+        exec(input?: URLPatternInput, baseURL?: string | URL): URLPatternResult | null;
+        test(input?: URLPatternInput, baseURL?: string | URL): boolean;
+    }
+    var URLPattern: {
+        prototype: URLPattern;
+        new (input: URLPatternInput, baseURL: string | URL, options?: URLPatternOptions): URLPattern;
+        new (input?: URLPatternInput, options?: URLPatternOptions): URLPattern;
+    };
+    interface URLSearchParams {
+        readonly size: number;
+        append(name: string, value: string): void;
+        delete(name: string, value?: string): void;
+        get(name: string): string | null;
+        getAll(name: string): string[];
+        has(name: string, value?: string): boolean;
+        set(name: string, value: string): void;
+        sort(): void;
+        forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
+        [Symbol.iterator](): URLSearchParamsIterator<[
+            string,
+            string
+        ]>;
+        entries(): URLSearchParamsIterator<[
+            string,
+            string
+        ]>;
+        keys(): URLSearchParamsIterator<string>;
+        values(): URLSearchParamsIterator<string>;
+    }
+    var URLSearchParams: {
+        prototype: URLSearchParams;
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    };
+    interface URLSearchParamsIterator<T> extends NodeJS.Iterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+        [Symbol.iterator](): URLSearchParamsIterator<T>;
+    }
+}
+declare module "url" {
+    export * from "node:url";
+}

package/types/node/util/types.d.ts

@@ -0,0 +1,49 @@
+declare module "node:util/types" {
+    import { KeyObject, webcrypto } from "node:crypto";
+    function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike;
+    function isArgumentsObject(object: unknown): object is IArguments;
+    function isArrayBuffer(object: unknown): object is ArrayBuffer;
+    function isArrayBufferView(object: unknown): object is NodeJS.ArrayBufferView;
+    function isAsyncFunction(object: unknown): boolean;
+    function isBigInt64Array(value: unknown): value is BigInt64Array;
+    function isBigIntObject(object: unknown): object is BigInt;
+    function isBigUint64Array(value: unknown): value is BigUint64Array;
+    function isBooleanObject(object: unknown): object is Boolean;
+    function isBoxedPrimitive(object: unknown): object is String | Number | BigInt | Boolean | Symbol;
+    function isDataView(object: unknown): object is DataView;
+    function isDate(object: unknown): object is Date;
+    function isExternal(object: unknown): boolean;
+    function isFloat16Array(object: unknown): object is Float16Array;
+    function isFloat32Array(object: unknown): object is Float32Array;
+    function isFloat64Array(object: unknown): object is Float64Array;
+    function isGeneratorFunction(object: unknown): object is GeneratorFunction;
+    function isGeneratorObject(object: unknown): object is Generator;
+    function isInt8Array(object: unknown): object is Int8Array;
+    function isInt16Array(object: unknown): object is Int16Array;
+    function isInt32Array(object: unknown): object is Int32Array;
+    function isMap<T>(object: T | {}): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>;
+    function isMapIterator(object: unknown): boolean;
+    function isModuleNamespaceObject(value: unknown): boolean;
+    function isNativeError(object: unknown): object is Error;
+    function isNumberObject(object: unknown): object is Number;
+    function isPromise(object: unknown): object is Promise<unknown>;
+    function isProxy(object: unknown): boolean;
+    function isRegExp(object: unknown): object is RegExp;
+    function isSet<T>(object: T | {}): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
+    function isSetIterator(object: unknown): boolean;
+    function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer;
+    function isStringObject(object: unknown): object is String;
+    function isSymbolObject(object: unknown): object is Symbol;
+    function isTypedArray(object: unknown): object is NodeJS.TypedArray;
+    function isUint8Array(object: unknown): object is Uint8Array;
+    function isUint8ClampedArray(object: unknown): object is Uint8ClampedArray;
+    function isUint16Array(object: unknown): object is Uint16Array;
+    function isUint32Array(object: unknown): object is Uint32Array;
+    function isWeakMap(object: unknown): object is WeakMap<object, unknown>;
+    function isWeakSet(object: unknown): object is WeakSet<object>;
+    function isKeyObject(object: unknown): object is KeyObject;
+    function isCryptoKey(object: unknown): object is webcrypto.CryptoKey;
+}
+declare module "util/types" {
+    export * from "node:util/types";
+}

package/types/node/util.d.ts

@@ -0,0 +1,320 @@
+declare module "node:util" {
+    export * as types from "node:util/types";
+    export type InspectStyle = "special" | "number" | "bigint" | "boolean" | "undefined" | "null" | "string" | "symbol" | "date" | "name" | "regexp" | "module";
+    export interface InspectStyles extends Record<InspectStyle, InspectColor | ((value: string) => string)> {
+        regexp: {
+            (value: string): string;
+            colors: InspectColor[];
+        };
+    }
+    export type InspectColorModifier = "reset" | "bold" | "dim" | "italic" | "underline" | "blink" | "inverse" | "hidden" | "strikethrough" | "doubleunderline";
+    export type InspectColorForeground = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+    export type InspectColorBackground = `bg${Capitalize<InspectColorForeground>}`;
+    export type InspectColor = InspectColorModifier | InspectColorForeground | InspectColorBackground;
+    export interface InspectColors extends Record<InspectColor, [
+        number,
+        number
+    ]> {
+    }
+    export interface InspectOptions {
+        showHidden?: boolean | undefined;
+        depth?: number | null | undefined;
+        colors?: boolean | undefined;
+        customInspect?: boolean | undefined;
+        showProxy?: boolean | undefined;
+        maxArrayLength?: number | null | undefined;
+        maxStringLength?: number | null | undefined;
+        breakLength?: number | undefined;
+        compact?: boolean | number | undefined;
+        sorted?: boolean | ((a: string, b: string) => number) | undefined;
+        getters?: "get" | "set" | boolean | undefined;
+        numericSeparator?: boolean | undefined;
+    }
+    export interface InspectContext extends Required<InspectOptions> {
+        stylize(text: string, styleType: InspectStyle): string;
+    }
+    import _inspect = inspect;
+    export interface Inspectable {
+        [inspect.custom](depth: number, options: InspectContext, inspect: typeof _inspect): any;
+    }
+    export type Style = Exclude<InspectStyle, "name">;
+    export type CustomInspectFunction = (depth: number, options: InspectContext) => any;
+    export interface InspectOptionsStylized extends InspectContext {
+    }
+    export type Modifiers = InspectColorModifier;
+    export type ForegroundColors = InspectColorForeground;
+    export type BackgroundColors = InspectColorBackground;
+    export interface CallSiteObject {
+        functionName: string;
+        scriptName: string;
+        scriptId: string;
+        lineNumber: number;
+        columnNumber: number;
+    }
+    export type DiffEntry = [
+        operation: -1 | 0 | 1,
+        value: string
+    ];
+    export function diff(actual: string | readonly string[], expected: string | readonly string[]): DiffEntry[];
+    export function format(format?: any, ...param: any[]): string;
+    export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    export interface GetCallSitesOptions {
+        sourceMap?: boolean | undefined;
+    }
+    export function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[];
+    export function getCallSites(options: GetCallSitesOptions): CallSiteObject[];
+    export function getSystemErrorName(err: number): string;
+    export function setTraceSigInt(enable: boolean): void;
+    export function getSystemErrorMap(): Map<number, [
+        string,
+        string
+    ]>;
+    export function getSystemErrorMessage(err: number): string;
+    export function toUSVString(string: string): string;
+    export function transferableAbortController(): AbortController;
+    export function transferableAbortSignal(signal: AbortSignal): AbortSignal;
+    export function aborted(signal: AbortSignal, resource: any): Promise<void>;
+    export function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
+    export function inspect(object: any, options?: InspectOptions): string;
+    export namespace inspect {
+        const custom: unique symbol;
+        let colors: InspectColors;
+        let styles: InspectStyles;
+        let defaultOptions: InspectOptions;
+        let replDefaults: InspectOptions;
+    }
+    export function isArray(object: unknown): object is unknown[];
+    export function inherits(constructor: unknown, superConstructor: unknown): void;
+    export function convertProcessSignalToExitCode(signal: NodeJS.Signals): number;
+    export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
+    export interface DebugLogger extends DebugLoggerFunction {
+        enabled: boolean;
+    }
+    export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
+    export { debuglog as debug };
+    export interface DeprecateOptions {
+        modifyPrototype?: boolean | undefined;
+    }
+    export function deprecate<T extends Function>(fn: T, msg: string, code?: string, options?: DeprecateOptions): T;
+    export interface IsDeepStrictEqualOptions {
+        skipPrototype?: boolean | undefined;
+    }
+    export function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): boolean;
+    export function stripVTControlCharacters(str: string): string;
+    export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    export function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    export function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3, T4, T5, T6>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, T3, T4, T5, T6, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
+        __promisify__: TCustom;
+    }
+    export interface CustomPromisifySymbol<TCustom extends Function> extends Function {
+        [promisify.custom]: TCustom;
+    }
+    export type CustomPromisify<TCustom extends Function> = CustomPromisifySymbol<TCustom> | CustomPromisifyLegacy<TCustom>;
+    export function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
+    export function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>;
+    export function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
+    export function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>;
+    export function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
+    export function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>;
+    export function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>;
+    export function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
+    export function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
+    export function promisify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>;
+    export function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
+    export function promisify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>;
+    export function promisify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
+    export function promisify(fn: Function): Function;
+    export namespace promisify {
+        const custom: unique symbol;
+    }
+    export function parseEnv(content: string): NodeJS.Dict<string>;
+    export interface StyleTextOptions {
+        validateStream?: boolean | undefined;
+        stream?: NodeJS.WritableStream | undefined;
+    }
+    export function styleText(format: InspectColor | readonly InspectColor[], text: string, options?: StyleTextOptions): string;
+    export interface EncodeIntoResult extends TextEncoderEncodeIntoResult {
+    }
+    export function parseArgs<T extends ParseArgsConfig>(config?: T): ParsedResults<T>;
+    export type ParseArgsOptionsType = "boolean" | "string";
+    export interface ParseArgsOptionDescriptor {
+        type: ParseArgsOptionsType;
+        multiple?: boolean | undefined;
+        short?: string | undefined;
+        default?: string | boolean | string[] | boolean[] | undefined;
+    }
+    export interface ParseArgsOptionsConfig {
+        [longOption: string]: ParseArgsOptionDescriptor;
+    }
+    export interface ParseArgsConfig {
+        args?: readonly string[] | undefined;
+        options?: ParseArgsOptionsConfig | undefined;
+        strict?: boolean | undefined;
+        allowPositionals?: boolean | undefined;
+        allowNegative?: boolean | undefined;
+        tokens?: boolean | undefined;
+    }
+    type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true ? IfTrue : T extends false ? IfFalse : IfTrue;
+    type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false ? IfFalse : T extends true ? IfTrue : IfFalse;
+    type ExtractOptionValue<T extends ParseArgsConfig, O extends ParseArgsOptionDescriptor> = IfDefaultsTrue<T["strict"], O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : string | boolean, string | boolean>;
+    type ApplyOptionalModifiers<O extends ParseArgsOptionsConfig, V extends Record<keyof O, unknown>> = ({
+        -readonly [LongOption in keyof O]?: V[LongOption];
+    } & {
+        [LongOption in keyof O as O[LongOption]["default"] extends {} ? LongOption : never]: V[LongOption];
+    }) extends infer P ? {
+        [K in keyof P]: P[K];
+    } : never;
+    type ParsedValues<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], unknown, {
+        [longOption: string]: undefined | string | boolean;
+    }> & (T["options"] extends ParseArgsOptionsConfig ? ApplyOptionalModifiers<T["options"], {
+        [LongOption in keyof T["options"]]: IfDefaultsFalse<T["options"][LongOption]["multiple"], Array<ExtractOptionValue<T, T["options"][LongOption]>>, ExtractOptionValue<T, T["options"][LongOption]>>;
+    }> : {});
+    type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], IfDefaultsFalse<T["allowPositionals"], string[], [
+    ]>, IfDefaultsTrue<T["allowPositionals"], string[], [
+    ]>>;
+    type PreciseTokenForOptions<K extends string, O extends ParseArgsOptionDescriptor> = O["type"] extends "string" ? {
+        kind: "option";
+        index: number;
+        name: K;
+        rawName: string;
+        value: string;
+        inlineValue: boolean;
+    } : O["type"] extends "boolean" ? {
+        kind: "option";
+        index: number;
+        name: K;
+        rawName: string;
+        value: undefined;
+        inlineValue: undefined;
+    } : OptionToken & {
+        name: K;
+    };
+    type TokenForOptions<T extends ParseArgsConfig, K extends keyof T["options"] = keyof T["options"]> = K extends unknown ? T["options"] extends ParseArgsOptionsConfig ? PreciseTokenForOptions<K & string, T["options"][K]> : OptionToken : never;
+    type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], TokenForOptions<T>, OptionToken>;
+    type ParsedPositionalToken<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], IfDefaultsFalse<T["allowPositionals"], {
+        kind: "positional";
+        index: number;
+        value: string;
+    }, never>, IfDefaultsTrue<T["allowPositionals"], {
+        kind: "positional";
+        index: number;
+        value: string;
+    }, never>>;
+    type ParsedTokens<T extends ParseArgsConfig> = Array<ParsedOptionToken<T> | ParsedPositionalToken<T> | {
+        kind: "option-terminator";
+        index: number;
+    }>;
+    type PreciseParsedResults<T extends ParseArgsConfig> = IfDefaultsFalse<T["tokens"], {
+        values: ParsedValues<T>;
+        positionals: ParsedPositionals<T>;
+        tokens: ParsedTokens<T>;
+    }, {
+        values: ParsedValues<T>;
+        positionals: ParsedPositionals<T>;
+    }>;
+    type OptionToken = {
+        kind: "option";
+        index: number;
+        name: string;
+        rawName: string;
+        value: string;
+        inlineValue: boolean;
+    } | {
+        kind: "option";
+        index: number;
+        name: string;
+        rawName: string;
+        value: undefined;
+        inlineValue: undefined;
+    };
+    type Token = OptionToken | {
+        kind: "positional";
+        index: number;
+        value: string;
+    } | {
+        kind: "option-terminator";
+        index: number;
+    };
+    type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T ? {
+        values: {
+            [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+        };
+        positionals: string[];
+        tokens?: Token[];
+    } : PreciseParsedResults<T>;
+    export class MIMEType {
+        constructor(input: string | {
+            toString: () => string;
+        });
+        type: string;
+        subtype: string;
+        readonly essence: string;
+        readonly params: MIMEParams;
+        toString(): string;
+    }
+    export class MIMEParams {
+        delete(name: string): void;
+        entries(): NodeJS.Iterator<[
+            name: string,
+            value: string
+        ]>;
+        get(name: string): string | null;
+        has(name: string): boolean;
+        keys(): NodeJS.Iterator<string>;
+        set(name: string, value: string): void;
+        values(): NodeJS.Iterator<string>;
+        [Symbol.iterator](): NodeJS.Iterator<[
+            name: string,
+            value: string
+        ]>;
+    }
+    export interface TextDecodeOptions {
+        stream?: boolean;
+    }
+    export interface TextDecoderCommon {
+        readonly encoding: string;
+        readonly fatal: boolean;
+        readonly ignoreBOM: boolean;
+    }
+    export interface TextDecoderOptions {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    }
+    export interface TextEncoderCommon {
+        readonly encoding: string;
+    }
+    export interface TextEncoderEncodeIntoResult {
+        read: number;
+        written: number;
+    }
+    export interface TextDecoder extends TextDecoderCommon {
+        decode(input?: NodeJS.AllowSharedBufferSource, options?: TextDecodeOptions): string;
+    }
+    export var TextDecoder: {
+        prototype: TextDecoder;
+        new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    };
+    export interface TextEncoder extends TextEncoderCommon {
+        encode(input?: string): NodeJS.NonSharedUint8Array;
+        encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+    }
+    export var TextEncoder: {
+        prototype: TextEncoder;
+        new (): TextEncoder;
+    };
+}
+declare module "util" {
+    export * from "node:util";
+}