@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/cluster.d.ts

@@ -0,0 +1,118 @@
+declare module "node:cluster" {
+    import * as child_process from "node:child_process";
+    import { EventEmitter, InternalEventEmitter } from "node:events";
+    class Worker implements EventEmitter {
+        constructor(options?: cluster.WorkerOptions);
+        id: number;
+        process: child_process.ChildProcess;
+        send(message: child_process.Serializable, callback?: (error: Error | null) => void): boolean;
+        send(message: child_process.Serializable, sendHandle: child_process.SendHandle, callback?: (error: Error | null) => void): boolean;
+        send(message: child_process.Serializable, sendHandle: child_process.SendHandle, options?: child_process.MessageOptions, callback?: (error: Error | null) => void): boolean;
+        kill(signal?: string): void;
+        destroy(signal?: string): void;
+        disconnect(): this;
+        isConnected(): boolean;
+        isDead(): boolean;
+        exitedAfterDisconnect: boolean;
+    }
+    interface Worker extends InternalEventEmitter<cluster.WorkerEventMap> {
+    }
+    type _Worker = Worker;
+    namespace cluster {
+        interface Worker extends _Worker {
+        }
+        interface WorkerOptions {
+            id?: number | undefined;
+            process?: child_process.ChildProcess | undefined;
+            state?: string | undefined;
+        }
+        interface WorkerEventMap {
+            "disconnect": [
+            ];
+            "error": [
+                error: Error
+            ];
+            "exit": [
+                code: number,
+                signal: string
+            ];
+            "listening": [
+                address: Address
+            ];
+            "message": [
+                message: any,
+                handle: child_process.SendHandle
+            ];
+            "online": [
+            ];
+        }
+        interface ClusterSettings {
+            execArgv?: string[] | undefined;
+            exec?: string | undefined;
+            args?: readonly string[] | undefined;
+            silent?: boolean | undefined;
+            stdio?: any[] | undefined;
+            uid?: number | undefined;
+            gid?: number | undefined;
+            inspectPort?: number | (() => number) | undefined;
+            serialization?: "json" | "advanced" | undefined;
+            cwd?: string | undefined;
+            windowsHide?: boolean | undefined;
+        }
+        interface Address {
+            address: string;
+            port: number;
+            addressType: 4 | 6 | -1 | "udp4" | "udp6";
+        }
+        interface ClusterEventMap {
+            "disconnect": [
+                worker: Worker
+            ];
+            "exit": [
+                worker: Worker,
+                code: number,
+                signal: string
+            ];
+            "fork": [
+                worker: Worker
+            ];
+            "listening": [
+                worker: Worker,
+                address: Address
+            ];
+            "message": [
+                worker: Worker,
+                message: any,
+                handle: child_process.SendHandle
+            ];
+            "online": [
+                worker: Worker
+            ];
+            "setup": [
+                settings: ClusterSettings
+            ];
+        }
+        interface Cluster extends InternalEventEmitter<ClusterEventMap> {
+            Worker: typeof Worker;
+            disconnect(callback?: () => void): void;
+            fork(env?: any): Worker;
+            readonly isMaster: boolean;
+            readonly isPrimary: boolean;
+            readonly isWorker: boolean;
+            schedulingPolicy: number;
+            readonly settings: ClusterSettings;
+            setupMaster(settings?: ClusterSettings): void;
+            setupPrimary(settings?: ClusterSettings): void;
+            readonly worker?: Worker;
+            readonly workers?: NodeJS.Dict<Worker>;
+            readonly SCHED_NONE: number;
+            readonly SCHED_RR: number;
+        }
+    }
+    var cluster: cluster.Cluster;
+    export = cluster;
+}
+declare module "cluster" {
+    import cluster = require("node:cluster");
+    export = cluster;
+}

package/types/node/compatibility/iterators.d.ts

@@ -0,0 +1,11 @@
+interface IteratorObject<T, TReturn, TNext> {
+}
+interface AsyncIteratorObject<T, TReturn, TNext> {
+}
+declare namespace NodeJS {
+    interface Iterator<T, TReturn, TNext> extends globalThis.Iterator<T, TReturn, TNext> {
+    }
+    interface AsyncIterator<T, TReturn, TNext> extends globalThis.AsyncIterator<T, TReturn, TNext> {
+    }
+    type BuiltinIteratorReturn = ReturnType<any[][typeof Symbol.iterator]> extends globalThis.Iterator<any, infer TReturn> ? TReturn : any;
+}

package/types/node/console.d.ts

@@ -0,0 +1,48 @@
+declare module "node:console" {
+    import { InspectOptions } from "node:util";
+    namespace console {
+        interface ConsoleOptions {
+            stdout: NodeJS.WritableStream;
+            stderr?: NodeJS.WritableStream | undefined;
+            ignoreErrors?: boolean | undefined;
+            colorMode?: boolean | "auto" | undefined;
+            inspectOptions?: InspectOptions | ReadonlyMap<NodeJS.WritableStream, InspectOptions> | undefined;
+            groupIndentation?: number | undefined;
+        }
+        interface Console {
+            readonly Console: {
+                prototype: Console;
+                new (stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
+                new (options: ConsoleOptions): Console;
+            };
+            assert(condition?: unknown, ...data: any[]): void;
+            clear(): void;
+            count(label?: string): void;
+            countReset(label?: string): void;
+            debug(...data: any[]): void;
+            dir(item?: any, options?: InspectOptions): void;
+            dirxml(...data: any[]): void;
+            error(...data: any[]): void;
+            group(...data: any[]): void;
+            groupCollapsed(...data: any[]): void;
+            groupEnd(): void;
+            info(...data: any[]): void;
+            log(...data: any[]): void;
+            table(tabularData?: any, properties?: string[]): void;
+            time(label?: string): void;
+            timeEnd(label?: string): void;
+            timeLog(label?: string, ...data: any[]): void;
+            trace(...data: any[]): void;
+            warn(...data: any[]): void;
+            profile(label?: string): void;
+            profileEnd(label?: string): void;
+            timeStamp(label?: string): void;
+        }
+    }
+    var console: console.Console;
+    export = console;
+}
+declare module "console" {
+    import console = require("node:console");
+    export = console;
+}

package/types/node/constants.d.ts

@@ -0,0 +1,8 @@
+declare module "node:constants" {
+    const constants: typeof import("node:os").constants.dlopen & typeof import("node:os").constants.errno & typeof import("node:os").constants.priority & typeof import("node:os").constants.signals & typeof import("node:fs").constants & typeof import("node:crypto").constants;
+    export = constants;
+}
+declare module "constants" {
+    import constants = require("node:constants");
+    export = constants;
+}