@volter/tabnode 0.4.0 → 0.5.0

package/dist/shims/crypto.d.ts

@@ -5,93 +5,514 @@
  * because a guest calls them synchronously and WebCrypto is async-only.
  * Random values and asymmetric signing use WebCrypto, which does have them.
  */
-import { Buffer as HostBuffer } from 'buffer/index.js';
-import { EventEmitter } from '../node-lib/events-module';
 import { cryptoConstants as constants } from './crypto-constants';
 export { constants };
-export declare function randomBytes(size: number): Buffer;
-export declare function randomBytes(size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
-export declare function randomFillSync<T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset?: number, size?: number): T;
-/**
- * Node's asynchronous fill. The overloads are Node's: `(buf, cb)`,
- * `(buf, offset, cb)`, `(buf, offset, size, cb)`, with the same argument
- * checks `randomFillSync` makes.
- */
-export declare function randomFill<T extends ArrayBufferView | ArrayBufferLike>(buffer: T, callback: (error: Error | null, buffer: T) => void): void;
-export declare function randomFill<T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, callback: (error: Error | null, buffer: T) => void): void;
-export declare function randomFill<T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, size: number, callback: (error: Error | null, buffer: T) => void): void;
-export declare function randomUUID(): string;
-export declare function randomInt(max: number): number;
-export declare function randomInt(min: number, max: number): number;
-export declare function randomInt(max: number, callback: (error: undefined, value: number) => void): void;
-export declare function randomInt(min: number, max: number, callback: (error: undefined, value: number) => void): void;
-export declare function getRandomValues<T extends ArrayBufferView>(array: T): T;
-/**
- * Node throws ERR_CRYPTO_UNSUPPORTED_OPERATION rather than returning
- * something that only looks like a result; so does this shim.
- */
-export declare function unsupported(operation: string): never;
-type HostBytes = InstanceType<typeof HostBuffer>;
-declare class Hash {
-    private state;
-    private done;
+interface DigestState {
+    update(data: Uint8Array): DigestState;
+    digest(): Uint8Array;
+    clone?(): DigestState;
+    [field: string]: unknown;
+}
+/** Native crypto allocates guest results and classes in the caller's graph. */
+export declare function createCryptoModule(require?: (name: string) => any): {
+    unsupported: (operation: string) => never;
+    randomBytes: {
+        (size: number): Buffer;
+        (size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
+    };
+    randomFill: {
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, callback: (error: Error | null, buffer: T) => void): void;
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, callback: (error: Error | null, buffer: T) => void): void;
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, size: number, callback: (error: Error | null, buffer: T) => void): void;
+    };
+    randomFillSync: <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset?: number, size?: number) => T;
+    randomUUID: () => string;
+    randomInt: {
+        (max: number): number;
+        (min: number, max: number): number;
+        (max: number, callback: (error: undefined, value: number) => void): void;
+        (min: number, max: number, callback: (error: undefined, value: number) => void): void;
+    };
+    getRandomValues: <T extends ArrayBufferView>(array: T) => T;
+    hash: (algorithm: string, data: unknown, outputEncoding?: string) => Buffer | string;
+    createHash: (algorithm: string, options?: {
+        outputLength?: number;
+    }) => {
+        "__#private@#state": DigestState;
+        "__#private@#done": boolean;
+        readonly algorithm: string;
+        update(data: unknown, inputEncoding?: string): /*elided*/ any;
+        digest(outputEncoding?: string): Buffer | string;
+        digestAsync(outputEncoding?: string): Promise<Buffer | string>;
+        copy(): /*elided*/ any;
+    };
+    createHmac: (algorithm: string, key: unknown, options?: {
+        encoding?: string;
+    }) => {
+        "__#private@#inner": DigestState;
+        "__#private@#outer": DigestState;
+        "__#private@#done": boolean;
+        update(data: unknown, inputEncoding?: string): /*elided*/ any;
+        digest(outputEncoding?: string): Buffer | string;
+        digestAsync(outputEncoding?: string): Promise<Buffer | string>;
+    };
+    createSign: (algorithm: string) => {
+        "__#private@#algorithm": string;
+        "__#private@#data": Uint8Array[];
+        update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+        sign(privateKey: string | Buffer<ArrayBufferLike> | {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        } | {
+            key: string | Buffer;
+            passphrase?: string;
+        }, outputEncoding?: string): Buffer | string;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    createVerify: (algorithm: string) => {
+        "__#private@#algorithm": string;
+        "__#private@#data": Uint8Array[];
+        update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+        verify(publicKey: string | Buffer<ArrayBufferLike> | {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        } | {
+            key: string | Buffer;
+            passphrase?: string;
+        }, signature: Buffer | string, signatureEncoding?: string): boolean;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    sign: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, callback?: (error: Error | null, signature: Buffer) => void) => Buffer | void;
+    verify: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, signature: Buffer | Uint8Array, callback?: (error: Error | null, result: boolean) => void) => boolean | void;
+    pbkdf2: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void) => void;
+    pbkdf2Sync: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string) => Buffer;
+    timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean;
+    getCiphers: () => string[];
+    getHashes: () => string[];
+    constants: {
+        SSL_OP_ALL: number;
+        RSA_PKCS1_PADDING: number;
+        RSA_PKCS1_OAEP_PADDING: number;
+        RSA_PKCS1_PSS_PADDING: number;
+    };
+    KeyObject: {
+        new (type: "public" | "private" | "secret", keyData: CryptoKey | Uint8Array, algorithm?: string): {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        };
+    };
+    createSecretKey: (key: (string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>) | ArrayBufferView, encoding?: string) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+    createPublicKey: (key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+    createPrivateKey: (key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+};
+declare const cryptoModule: {
+    unsupported: (operation: string) => never;
+    randomBytes: {
+        (size: number): Buffer;
+        (size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
+    };
+    randomFill: {
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, callback: (error: Error | null, buffer: T) => void): void;
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, callback: (error: Error | null, buffer: T) => void): void;
+        <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, size: number, callback: (error: Error | null, buffer: T) => void): void;
+    };
+    randomFillSync: <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset?: number, size?: number) => T;
+    randomUUID: () => string;
+    randomInt: {
+        (max: number): number;
+        (min: number, max: number): number;
+        (max: number, callback: (error: undefined, value: number) => void): void;
+        (min: number, max: number, callback: (error: undefined, value: number) => void): void;
+    };
+    getRandomValues: <T extends ArrayBufferView>(array: T) => T;
+    hash: (algorithm: string, data: unknown, outputEncoding?: string) => Buffer | string;
+    createHash: (algorithm: string, options?: {
+        outputLength?: number;
+    }) => {
+        "__#private@#state": DigestState;
+        "__#private@#done": boolean;
+        readonly algorithm: string;
+        update(data: unknown, inputEncoding?: string): /*elided*/ any;
+        digest(outputEncoding?: string): Buffer | string;
+        digestAsync(outputEncoding?: string): Promise<Buffer | string>;
+        copy(): /*elided*/ any;
+    };
+    createHmac: (algorithm: string, key: unknown, options?: {
+        encoding?: string;
+    }) => {
+        "__#private@#inner": DigestState;
+        "__#private@#outer": DigestState;
+        "__#private@#done": boolean;
+        update(data: unknown, inputEncoding?: string): /*elided*/ any;
+        digest(outputEncoding?: string): Buffer | string;
+        digestAsync(outputEncoding?: string): Promise<Buffer | string>;
+    };
+    createSign: (algorithm: string) => {
+        "__#private@#algorithm": string;
+        "__#private@#data": Uint8Array[];
+        update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+        sign(privateKey: string | Buffer<ArrayBufferLike> | {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        } | {
+            key: string | Buffer;
+            passphrase?: string;
+        }, outputEncoding?: string): Buffer | string;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    createVerify: (algorithm: string) => {
+        "__#private@#algorithm": string;
+        "__#private@#data": Uint8Array[];
+        update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+        verify(publicKey: string | Buffer<ArrayBufferLike> | {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        } | {
+            key: string | Buffer;
+            passphrase?: string;
+        }, signature: Buffer | string, signatureEncoding?: string): boolean;
+        addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        removeAllListeners(event?: string | symbol): /*elided*/ any;
+        setMaxListeners(n: number): /*elided*/ any;
+        getMaxListeners(): number;
+        listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+        emit(event: string | symbol, ...args: unknown[]): boolean;
+        listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+        prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+        eventNames(): Array<string | symbol>;
+    };
+    sign: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, callback?: (error: Error | null, signature: Buffer) => void) => Buffer | void;
+    verify: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, signature: Buffer | Uint8Array, callback?: (error: Error | null, result: boolean) => void) => boolean | void;
+    pbkdf2: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void) => void;
+    pbkdf2Sync: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string) => Buffer;
+    timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean;
+    getCiphers: () => string[];
+    getHashes: () => string[];
+    constants: {
+        SSL_OP_ALL: number;
+        RSA_PKCS1_PADDING: number;
+        RSA_PKCS1_OAEP_PADDING: number;
+        RSA_PKCS1_PSS_PADDING: number;
+    };
+    KeyObject: {
+        new (type: "public" | "private" | "secret", keyData: CryptoKey | Uint8Array, algorithm?: string): {
+            "__#private@#_keyData": CryptoKey | Uint8Array;
+            "__#private@#_type": "public" | "private" | "secret";
+            "__#private@#_algorithm"?: string;
+            get type(): string;
+            get asymmetricKeyType(): string | undefined;
+            get symmetricKeySize(): number | undefined;
+            export(options?: {
+                type?: string;
+                format?: string;
+            }): Buffer | string;
+        };
+    };
+    createSecretKey: (key: (string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>) | ArrayBufferView, encoding?: string) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+    createPublicKey: (key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+    createPrivateKey: (key: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }) => {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    };
+};
+export declare const randomBytes: {
+    (size: number): Buffer;
+    (size: number, callback: (error: Error | null, buffer: Buffer) => void): void;
+}, randomFillSync: <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset?: number, size?: number) => T, randomFill: {
+    <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, callback: (error: Error | null, buffer: T) => void): void;
+    <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, callback: (error: Error | null, buffer: T) => void): void;
+    <T extends ArrayBufferView | ArrayBufferLike>(buffer: T, offset: number, size: number, callback: (error: Error | null, buffer: T) => void): void;
+}, randomUUID: () => string, randomInt: {
+    (max: number): number;
+    (min: number, max: number): number;
+    (max: number, callback: (error: undefined, value: number) => void): void;
+    (min: number, max: number, callback: (error: undefined, value: number) => void): void;
+}, getRandomValues: <T extends ArrayBufferView>(array: T) => T, unsupported: (operation: string) => never, createHash: (algorithm: string, options?: {
+    outputLength?: number;
+}) => {
+    "__#private@#state": DigestState;
+    "__#private@#done": boolean;
     readonly algorithm: string;
-    constructor(algorithm: string);
-    update(data: unknown, inputEncoding?: string): this;
+    update(data: unknown, inputEncoding?: string): /*elided*/ any;
     digest(outputEncoding?: string): Buffer | string;
     digestAsync(outputEncoding?: string): Promise<Buffer | string>;
-    copy(): Hash;
-}
-declare class Hmac {
-    private inner;
-    private outer;
-    private done;
-    constructor(algorithm: string, key: HostBytes);
-    update(data: unknown, inputEncoding?: string): this;
+    copy(): /*elided*/ any;
+}, createHmac: (algorithm: string, key: unknown, options?: {
+    encoding?: string;
+}) => {
+    "__#private@#inner": DigestState;
+    "__#private@#outer": DigestState;
+    "__#private@#done": boolean;
+    update(data: unknown, inputEncoding?: string): /*elided*/ any;
     digest(outputEncoding?: string): Buffer | string;
     digestAsync(outputEncoding?: string): Promise<Buffer | string>;
-}
-export declare function createHash(algorithm: string, options?: {
-    outputLength?: number;
-}): Hash;
-export declare function createHmac(algorithm: string, key: unknown, options?: {
-    encoding?: string;
-}): Hmac;
-/** The one-shot digest, `crypto.hash`, added in Node 21. */
-export declare function hash(algorithm: string, data: unknown, outputEncoding?: string): Buffer | string;
-type BinaryLike = string | Buffer | Uint8Array;
-export declare function pbkdf2Sync(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string): Buffer;
-export declare function pbkdf2(password: BinaryLike, salt: BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void): void;
-/**
- * Calculates and returns a signature for data using the given private key
- * This is the one-shot API that jose uses
- */
-export declare function sign(algorithm: string | null | undefined, data: Buffer | Uint8Array, key: KeyLike, callback?: (error: Error | null, signature: Buffer) => void): Buffer | void;
-/**
- * Verifies the given signature for data using the given key
- */
-export declare function verify(algorithm: string | null | undefined, data: Buffer | Uint8Array, key: KeyLike, signature: Buffer | Uint8Array, callback?: (error: Error | null, result: boolean) => void): boolean | void;
-export declare function createSign(algorithm: string): Sign;
-export declare function createVerify(algorithm: string): Verify;
-declare class Sign extends EventEmitter {
-    private algorithm;
-    private data;
-    constructor(algorithm: string);
-    update(data: string | Buffer | Uint8Array, encoding?: string): this;
-    sign(privateKey: KeyLike, outputEncoding?: string): Buffer | string;
-}
-declare class Verify extends EventEmitter {
-    private algorithm;
-    private data;
-    constructor(algorithm: string);
-    update(data: string | Buffer | Uint8Array, encoding?: string): this;
-    verify(publicKey: KeyLike, signature: Buffer | string, signatureEncoding?: string): boolean;
-}
-export declare class KeyObject {
-    private _keyData;
-    private _type;
-    private _algorithm?;
-    constructor(type: 'public' | 'private' | 'secret', keyData: CryptoKey | Uint8Array, algorithm?: string);
+}, hash: (algorithm: string, data: unknown, outputEncoding?: string) => Buffer | string, pbkdf2Sync: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string) => Buffer, pbkdf2: (password: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, salt: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void) => void, sign: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
     get type(): string;
     get asymmetricKeyType(): string | undefined;
     get symmetricKeySize(): number | undefined;
@@ -99,45 +520,165 @@ export declare class KeyObject {
         type?: string;
         format?: string;
     }): Buffer | string;
-}
-export declare function createSecretKey(key: BinaryLike | ArrayBufferView, encoding?: string): KeyObject;
-export declare function createPublicKey(key: KeyLike): KeyObject;
-export declare function createPrivateKey(key: KeyLike): KeyObject;
-export declare function timingSafeEqual(a: Buffer | Uint8Array, b: Buffer | Uint8Array): boolean;
-export declare function getCiphers(): string[];
-export declare function getHashes(): string[];
-type KeyLike = string | Buffer | KeyObject | {
+} | {
     key: string | Buffer;
     passphrase?: string;
-};
-declare const _default: {
-    randomBytes: typeof randomBytes;
-    randomFill: typeof randomFill;
-    randomFillSync: typeof randomFillSync;
-    randomUUID: typeof randomUUID;
-    randomInt: typeof randomInt;
-    getRandomValues: typeof getRandomValues;
-    hash: typeof hash;
-    createHash: typeof createHash;
-    createHmac: typeof createHmac;
-    createSign: typeof createSign;
-    createVerify: typeof createVerify;
-    sign: typeof sign;
-    verify: typeof verify;
-    pbkdf2: typeof pbkdf2;
-    pbkdf2Sync: typeof pbkdf2Sync;
-    timingSafeEqual: typeof timingSafeEqual;
-    getCiphers: typeof getCiphers;
-    getHashes: typeof getHashes;
-    constants: {
-        SSL_OP_ALL: number;
-        RSA_PKCS1_PADDING: number;
-        RSA_PKCS1_OAEP_PADDING: number;
-        RSA_PKCS1_PSS_PADDING: number;
+}, callback?: (error: Error | null, signature: Buffer) => void) => Buffer | void, verify: (algorithm: string | null | undefined, data: Buffer | Uint8Array, key: string | Buffer<ArrayBufferLike> | {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+} | {
+    key: string | Buffer;
+    passphrase?: string;
+}, signature: Buffer | Uint8Array, callback?: (error: Error | null, result: boolean) => void) => boolean | void, createSign: (algorithm: string) => {
+    "__#private@#algorithm": string;
+    "__#private@#data": Uint8Array[];
+    update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+    sign(privateKey: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, outputEncoding?: string): Buffer | string;
+    addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeAllListeners(event?: string | symbol): /*elided*/ any;
+    setMaxListeners(n: number): /*elided*/ any;
+    getMaxListeners(): number;
+    listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+    prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    eventNames(): Array<string | symbol>;
+}, createVerify: (algorithm: string) => {
+    "__#private@#algorithm": string;
+    "__#private@#data": Uint8Array[];
+    update(data: string | Buffer | Uint8Array, encoding?: string): /*elided*/ any;
+    verify(publicKey: string | Buffer<ArrayBufferLike> | {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
+    } | {
+        key: string | Buffer;
+        passphrase?: string;
+    }, signature: Buffer | string, signatureEncoding?: string): boolean;
+    addListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    on(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    once(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    off(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    removeAllListeners(event?: string | symbol): /*elided*/ any;
+    setMaxListeners(n: number): /*elided*/ any;
+    getMaxListeners(): number;
+    listeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    rawListeners(event: string | symbol): Array<import("../node-lib/events-module").EventListener>;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    listenerCount(event: string | symbol, listener?: import("../node-lib/events-module").EventListener): number;
+    prependListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    prependOnceListener(event: string | symbol, listener: import("../node-lib/events-module").EventListener): /*elided*/ any;
+    eventNames(): Array<string | symbol>;
+}, KeyObject: {
+    new (type: "public" | "private" | "secret", keyData: CryptoKey | Uint8Array, algorithm?: string): {
+        "__#private@#_keyData": CryptoKey | Uint8Array;
+        "__#private@#_type": "public" | "private" | "secret";
+        "__#private@#_algorithm"?: string;
+        get type(): string;
+        get asymmetricKeyType(): string | undefined;
+        get symmetricKeySize(): number | undefined;
+        export(options?: {
+            type?: string;
+            format?: string;
+        }): Buffer | string;
     };
-    KeyObject: typeof KeyObject;
-    createSecretKey: typeof createSecretKey;
-    createPublicKey: typeof createPublicKey;
-    createPrivateKey: typeof createPrivateKey;
-};
-export default _default;
+}, createSecretKey: (key: (string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>) | ArrayBufferView, encoding?: string) => {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+}, createPublicKey: (key: string | Buffer<ArrayBufferLike> | {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+} | {
+    key: string | Buffer;
+    passphrase?: string;
+}) => {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+}, createPrivateKey: (key: string | Buffer<ArrayBufferLike> | {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+} | {
+    key: string | Buffer;
+    passphrase?: string;
+}) => {
+    "__#private@#_keyData": CryptoKey | Uint8Array;
+    "__#private@#_type": "public" | "private" | "secret";
+    "__#private@#_algorithm"?: string;
+    get type(): string;
+    get asymmetricKeyType(): string | undefined;
+    get symmetricKeySize(): number | undefined;
+    export(options?: {
+        type?: string;
+        format?: string;
+    }): Buffer | string;
+}, timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean, getCiphers: () => string[], getHashes: () => string[];
+export type KeyObject = InstanceType<typeof KeyObject>;
+export default cryptoModule;