bun-types 1.2.6 → 1.2.7

package/jsc.d.ts

@@ -1,243 +1,229 @@
 declare module "bun:jsc" {
-	/**
-	 * This used to be called "describe" but it could be confused with the test runner.
-	 */
-	function jscDescribe(value: any): string;
-	function jscDescribeArray(args: any[]): string;
-	function gcAndSweep(): number;
-	function fullGC(): number;
-	function edenGC(): number;
-	function heapSize(): number;
-	function heapStats(): {
-		heapSize: number;
-		heapCapacity: number;
-		extraMemorySize: number;
-		objectCount: number;
-		protectedObjectCount: number;
-		globalObjectCount: number;
-		protectedGlobalObjectCount: number;
-		objectTypeCounts: Record<string, number>;
-		protectedObjectTypeCounts: Record<string, number>;
-	};
-	function memoryUsage(): {
-		current: number;
-		peak: number;
-		currentCommit: number;
-		peakCommit: number;
-		pageFaults: number;
-	};
-	function getRandomSeed(): number;
-	function setRandomSeed(value: number): void;
-	function isRope(input: string): boolean;
-	function callerSourceOrigin(): string;
-	function noFTL(func: (...args: any[]) => any): (...args: any[]) => any;
-	function noOSRExitFuzzing(
-		func: (...args: any[]) => any,
-	): (...args: any[]) => any;
-	function optimizeNextInvocation(func: (...args: any[]) => any): void;
-	function numberOfDFGCompiles(func: (...args: any[]) => any): number;
-	function releaseWeakRefs(): void;
-	function totalCompileTime(func: (...args: any[]) => any): number;
-	function reoptimizationRetryCount(func: (...args: any[]) => any): number;
-	function drainMicrotasks(): void;
+  /**
+   * This used to be called "describe" but it could be confused with the test runner.
+   */
+  function jscDescribe(value: any): string;
+  function jscDescribeArray(args: any[]): string;
+  function gcAndSweep(): number;
+  function fullGC(): number;
+  function edenGC(): number;
+  function heapSize(): number;
+  function heapStats(): {
+    heapSize: number;
+    heapCapacity: number;
+    extraMemorySize: number;
+    objectCount: number;
+    protectedObjectCount: number;
+    globalObjectCount: number;
+    protectedGlobalObjectCount: number;
+    objectTypeCounts: Record<string, number>;
+    protectedObjectTypeCounts: Record<string, number>;
+  };
+  function memoryUsage(): {
+    current: number;
+    peak: number;
+    currentCommit: number;
+    peakCommit: number;
+    pageFaults: number;
+  };
+  function getRandomSeed(): number;
+  function setRandomSeed(value: number): void;
+  function isRope(input: string): boolean;
+  function callerSourceOrigin(): string;
+  function noFTL(func: (...args: any[]) => any): (...args: any[]) => any;
+  function noOSRExitFuzzing(func: (...args: any[]) => any): (...args: any[]) => any;
+  function optimizeNextInvocation(func: (...args: any[]) => any): void;
+  function numberOfDFGCompiles(func: (...args: any[]) => any): number;
+  function releaseWeakRefs(): void;
+  function totalCompileTime(func: (...args: any[]) => any): number;
+  function reoptimizationRetryCount(func: (...args: any[]) => any): number;
+  function drainMicrotasks(): void;
 
-	/**
-	 * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
-	 *
-	 * Internally, this uses the serialization format from WebKit/Safari.
-	 *
-	 * @param value A JavaScript value, usually an object or array, to be converted.
-	 * @returns A SharedArrayBuffer that can be sent to another Bun instance.
-	 */
-	function serialize(
-		value: any,
-		options?: { binaryType?: "arraybuffer" },
-	): SharedArrayBuffer;
+  /**
+   * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
+   *
+   * Internally, this uses the serialization format from WebKit/Safari.
+   *
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @returns A SharedArrayBuffer that can be sent to another Bun instance.
+   */
+  function serialize(value: any, options?: { binaryType?: "arraybuffer" }): SharedArrayBuffer;
 
-	/**
-	 * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
-	 *
-	 * Internally, this uses the serialization format from WebKit/Safari.
-	 *
-	 * @param value A JavaScript value, usually an object or array, to be converted.
-	 * @returns A Buffer that can be sent to another Bun instance.
-	 */
-	function serialize(
-		value: any,
-		options?: { binaryType: "nodebuffer" },
-	): Buffer;
+  /**
+   * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
+   *
+   * Internally, this uses the serialization format from WebKit/Safari.
+   *
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @returns A Buffer that can be sent to another Bun instance.
+   */
+  function serialize(value: any, options?: { binaryType: "nodebuffer" }): Buffer;
 
-	/**
-	 * Convert an ArrayBuffer or Buffer to a JavaScript value compatible with the HTML Structured Clone Algorithm.
-	 *
-	 * @param value A serialized value, usually an ArrayBuffer or Buffer, to be converted.
-	 */
-	function deserialize(
-		value: ArrayBufferLike | NodeJS.TypedArray | Buffer,
-	): any;
+  /**
+   * Convert an ArrayBuffer or Buffer to a JavaScript value compatible with the HTML Structured Clone Algorithm.
+   *
+   * @param value A serialized value, usually an ArrayBuffer or Buffer, to be converted.
+   */
+  function deserialize(value: ArrayBufferLike | NodeJS.TypedArray | Buffer): any;
 
-	/**
-	 * Set the timezone used by Intl, Date, etc.
-	 *
-	 * @param timeZone A string representing the time zone to use, such as "America/Los_Angeles"
-	 *
-	 * @returns The normalized time zone string
-	 *
-	 * You can also set process.env.TZ to the time zone you want to use.
-	 * You can also view the current timezone with `Intl.DateTimeFormat().resolvedOptions().timeZone`
-	 */
-	function setTimeZone(timeZone: string): string;
+  /**
+   * Set the timezone used by Intl, Date, etc.
+   *
+   * @param timeZone A string representing the time zone to use, such as "America/Los_Angeles"
+   *
+   * @returns The normalized time zone string
+   *
+   * You can also set process.env.TZ to the time zone you want to use.
+   * You can also view the current timezone with `Intl.DateTimeFormat().resolvedOptions().timeZone`
+   */
+  function setTimeZone(timeZone: string): string;
 
-	interface SamplingProfile {
-		/**
-		 * A formatted summary of the top functions
-		 *
-		 * Example output:
-		 * ```js
-		 *
-		 * Sampling rate: 100.000000 microseconds. Total samples: 6858
-		 * Top functions as <numSamples  'functionName#hash:sourceID'>
-		 * 2948    '#<nil>:8'
-		 * 393    'visit#<nil>:8'
-		 * 263    'push#<nil>:8'
-		 * 164    'scan_ref_scoped#<nil>:8'
-		 * 164    'walk#<nil>:8'
-		 * 144    'pop#<nil>:8'
-		 * 107    'extract_candidates#<nil>:8'
-		 *  94    'get#<nil>:8'
-		 *  82    'Function#<nil>:4294967295'
-		 *  79    'set#<nil>:8'
-		 *  67    'forEach#<nil>:5'
-		 *  58    'collapse#<nil>:8'
-		 * ```
-		 */
-		functions: string;
-		/**
-		 * A formatted summary of the top bytecodes
-		 *
-		 * Example output:
-		 * ```js
-		 * Tier breakdown:
-		 * -----------------------------------
-		 * LLInt:                   106  (1.545640%)
-		 * Baseline:               2355  (34.339458%)
-		 * DFG:                    3290  (47.973170%)
-		 * FTL:                     833  (12.146398%)
-		 * js builtin:              132  (1.924759%)
-		 * Wasm:                      0  (0.000000%)
-		 * Host:                    111  (1.618548%)
-		 * RegExp:                   15  (0.218723%)
-		 * C/C++:                     0  (0.000000%)
-		 * Unknown Executable:      148  (2.158064%)
-		 *
-		 * Hottest bytecodes as <numSamples   'functionName#hash:JITType:bytecodeIndex'>
-		 * 273    'visit#<nil>:DFG:bc#63'
-		 * 121    'walk#<nil>:DFG:bc#7'
-		 * 119    '#<nil>:Baseline:bc#1'
-		 * 82    'Function#<nil>:None:<nil>'
-		 * 66    '#<nil>:DFG:bc#11'
-		 * 65    '#<nil>:DFG:bc#33'
-		 * 58    '#<nil>:Baseline:bc#7'
-		 * 53    '#<nil>:Baseline:bc#23'
-		 * 50    'forEach#<nil>:DFG:bc#83'
-		 * 49    'pop#<nil>:FTL:bc#65'
-		 * 47    '#<nil>:DFG:bc#99'
-		 * 45    '#<nil>:DFG:bc#16'
-		 * 44    '#<nil>:DFG:bc#7'
-		 * 44    '#<nil>:Baseline:bc#30'
-		 * 44    'push#<nil>:FTL:bc#214'
-		 * 41    '#<nil>:DFG:bc#50'
-		 * 39    'get#<nil>:DFG:bc#27'
-		 * 39    '#<nil>:Baseline:bc#0'
-		 * 36    '#<nil>:DFG:bc#27'
-		 * 36    'Dictionary#<nil>:DFG:bc#41'
-		 * 36    'visit#<nil>:DFG:bc#81'
-		 * 36    'get#<nil>:FTL:bc#11'
-		 * 32    'push#<nil>:FTL:bc#49'
-		 * 31    '#<nil>:DFG:bc#76'
-		 * 31    '#<nil>:DFG:bc#10'
-		 * 31    '#<nil>:DFG:bc#73'
-		 * 29    'set#<nil>:DFG:bc#28'
-		 * 28    'in_boolean_context#<nil>:DFG:bc#104'
-		 * 28    '#<nil>:Baseline:<nil>'
-		 * 28    'regExpSplitFast#<nil>:None:<nil>'
-		 * 26    'visit#<nil>:DFG:bc#95'
-		 * 26    'pop#<nil>:FTL:bc#120'
-		 * 25    '#<nil>:DFG:bc#23'
-		 * 25    'push#<nil>:FTL:bc#152'
-		 * 24    'push#<nil>:FTL:bc#262'
-		 * 24    '#<nil>:FTL:bc#10'
-		 * 23    'is_identifier_char#<nil>:DFG:bc#22'
-		 * 23    'visit#<nil>:DFG:bc#22'
-		 * 22    '#<nil>:FTL:bc#27'
-		 * 22    'indexOf#<nil>:None:<nil>'
-		 * ```
-		 */
-		bytecodes: string;
+  interface SamplingProfile {
+    /**
+     * A formatted summary of the top functions
+     *
+     * Example output:
+     * ```js
+     *
+     * Sampling rate: 100.000000 microseconds. Total samples: 6858
+     * Top functions as <numSamples  'functionName#hash:sourceID'>
+     * 2948    '#<nil>:8'
+     * 393    'visit#<nil>:8'
+     * 263    'push#<nil>:8'
+     * 164    'scan_ref_scoped#<nil>:8'
+     * 164    'walk#<nil>:8'
+     * 144    'pop#<nil>:8'
+     * 107    'extract_candidates#<nil>:8'
+     *  94    'get#<nil>:8'
+     *  82    'Function#<nil>:4294967295'
+     *  79    'set#<nil>:8'
+     *  67    'forEach#<nil>:5'
+     *  58    'collapse#<nil>:8'
+     * ```
+     */
+    functions: string;
+    /**
+     * A formatted summary of the top bytecodes
+     *
+     * Example output:
+     * ```js
+     * Tier breakdown:
+     * -----------------------------------
+     * LLInt:                   106  (1.545640%)
+     * Baseline:               2355  (34.339458%)
+     * DFG:                    3290  (47.973170%)
+     * FTL:                     833  (12.146398%)
+     * js builtin:              132  (1.924759%)
+     * Wasm:                      0  (0.000000%)
+     * Host:                    111  (1.618548%)
+     * RegExp:                   15  (0.218723%)
+     * C/C++:                     0  (0.000000%)
+     * Unknown Executable:      148  (2.158064%)
+     *
+     * Hottest bytecodes as <numSamples   'functionName#hash:JITType:bytecodeIndex'>
+     * 273    'visit#<nil>:DFG:bc#63'
+     * 121    'walk#<nil>:DFG:bc#7'
+     * 119    '#<nil>:Baseline:bc#1'
+     * 82    'Function#<nil>:None:<nil>'
+     * 66    '#<nil>:DFG:bc#11'
+     * 65    '#<nil>:DFG:bc#33'
+     * 58    '#<nil>:Baseline:bc#7'
+     * 53    '#<nil>:Baseline:bc#23'
+     * 50    'forEach#<nil>:DFG:bc#83'
+     * 49    'pop#<nil>:FTL:bc#65'
+     * 47    '#<nil>:DFG:bc#99'
+     * 45    '#<nil>:DFG:bc#16'
+     * 44    '#<nil>:DFG:bc#7'
+     * 44    '#<nil>:Baseline:bc#30'
+     * 44    'push#<nil>:FTL:bc#214'
+     * 41    '#<nil>:DFG:bc#50'
+     * 39    'get#<nil>:DFG:bc#27'
+     * 39    '#<nil>:Baseline:bc#0'
+     * 36    '#<nil>:DFG:bc#27'
+     * 36    'Dictionary#<nil>:DFG:bc#41'
+     * 36    'visit#<nil>:DFG:bc#81'
+     * 36    'get#<nil>:FTL:bc#11'
+     * 32    'push#<nil>:FTL:bc#49'
+     * 31    '#<nil>:DFG:bc#76'
+     * 31    '#<nil>:DFG:bc#10'
+     * 31    '#<nil>:DFG:bc#73'
+     * 29    'set#<nil>:DFG:bc#28'
+     * 28    'in_boolean_context#<nil>:DFG:bc#104'
+     * 28    '#<nil>:Baseline:<nil>'
+     * 28    'regExpSplitFast#<nil>:None:<nil>'
+     * 26    'visit#<nil>:DFG:bc#95'
+     * 26    'pop#<nil>:FTL:bc#120'
+     * 25    '#<nil>:DFG:bc#23'
+     * 25    'push#<nil>:FTL:bc#152'
+     * 24    'push#<nil>:FTL:bc#262'
+     * 24    '#<nil>:FTL:bc#10'
+     * 23    'is_identifier_char#<nil>:DFG:bc#22'
+     * 23    'visit#<nil>:DFG:bc#22'
+     * 22    '#<nil>:FTL:bc#27'
+     * 22    'indexOf#<nil>:None:<nil>'
+     * ```
+     */
+    bytecodes: string;
 
-		/**
-		 * Stack traces of the top functions
-		 */
-		stackTraces: string[];
-	}
+    /**
+     * Stack traces of the top functions
+     */
+    stackTraces: string[];
+  }
 
-	/**
-	 * Run JavaScriptCore's sampling profiler for a particular function
-	 *
-	 * This is pretty low-level.
-	 *
-	 * Things to know:
-	 * - LLint means "Low Level Interpreter", which is the interpreter that runs before any JIT compilation
-	 * - Baseline is the first JIT compilation tier. It's the least optimized, but the fastest to compile
-	 * - DFG means "Data Flow Graph", which is the second JIT compilation tier. It has some optimizations, but is slower to compile
-	 * - FTL means "Faster Than Light", which is the third JIT compilation tier. It has the most optimizations, but is the slowest to compile
-	 */
-	function profile<T extends (...args: any[]) => any>(
-		callback: T,
-		sampleInterval?: number,
-		...args: Parameters<T>
-	): ReturnType<T> extends Promise<infer U>
-		? Promise<SamplingProfile>
-		: SamplingProfile;
+  /**
+   * Run JavaScriptCore's sampling profiler for a particular function
+   *
+   * This is pretty low-level.
+   *
+   * Things to know:
+   * - LLint means "Low Level Interpreter", which is the interpreter that runs before any JIT compilation
+   * - Baseline is the first JIT compilation tier. It's the least optimized, but the fastest to compile
+   * - DFG means "Data Flow Graph", which is the second JIT compilation tier. It has some optimizations, but is slower to compile
+   * - FTL means "Faster Than Light", which is the third JIT compilation tier. It has the most optimizations, but is the slowest to compile
+   */
+  function profile<T extends (...args: any[]) => any>(
+    callback: T,
+    sampleInterval?: number,
+    ...args: Parameters<T>
+  ): ReturnType<T> extends Promise<infer U> ? Promise<SamplingProfile> : SamplingProfile;
 
-	/**
-	 * This returns objects which native code has explicitly protected from being
-	 * garbage collected
-	 *
-	 * By calling this function you create another reference to the object, which
-	 * will further prevent it from being garbage collected
-	 *
-	 * This function is mostly a debugging tool for bun itself.
-	 *
-	 * Warning: not all objects returned are supposed to be observable from JavaScript
-	 */
-	function getProtectedObjects(): any[];
+  /**
+   * This returns objects which native code has explicitly protected from being
+   * garbage collected
+   *
+   * By calling this function you create another reference to the object, which
+   * will further prevent it from being garbage collected
+   *
+   * This function is mostly a debugging tool for bun itself.
+   *
+   * Warning: not all objects returned are supposed to be observable from JavaScript
+   */
+  function getProtectedObjects(): any[];
 
-	/**
-	 * Start a remote debugging socket server on the given port.
-	 *
-	 * This exposes JavaScriptCore's built-in debugging server.
-	 *
-	 * This is untested. May not be supported yet on macOS
-	 */
-	function startRemoteDebugger(host?: string, port?: number): void;
+  /**
+   * Start a remote debugging socket server on the given port.
+   *
+   * This exposes JavaScriptCore's built-in debugging server.
+   *
+   * This is untested. May not be supported yet on macOS
+   */
+  function startRemoteDebugger(host?: string, port?: number): void;
 
-	/**
-	 * Run JavaScriptCore's sampling profiler
-	 */
-	function startSamplingProfiler(optionalDirectory?: string): void;
+  /**
+   * Run JavaScriptCore's sampling profiler
+   */
+  function startSamplingProfiler(optionalDirectory?: string): void;
 
-	/**
-	 * Non-recursively estimate the memory usage of an object, excluding the memory usage of
-	 * properties or other objects it references. For more accurate per-object
-	 * memory usage, use {@link Bun.generateHeapSnapshot}.
-	 *
-	 * This is a best-effort estimate. It may not be 100% accurate. When it's
-	 * wrong, it may mean the memory is non-contiguous (such as a large array).
-	 *
-	 * Passing a primitive type that isn't heap allocated returns 0.
-	 */
-	function estimateShallowMemoryUsageOf(
-		value: object | CallableFunction | bigint | symbol | string,
-	): number;
+  /**
+   * Non-recursively estimate the memory usage of an object, excluding the memory usage of
+   * properties or other objects it references. For more accurate per-object
+   * memory usage, use {@link Bun.generateHeapSnapshot}.
+   *
+   * This is a best-effort estimate. It may not be 100% accurate. When it's
+   * wrong, it may mean the memory is non-contiguous (such as a large array).
+   *
+   * Passing a primitive type that isn't heap allocated returns 0.
+   */
+  function estimateShallowMemoryUsageOf(value: object | CallableFunction | bigint | symbol | string): number;
 }

package/overrides.d.ts

@@ -1,74 +1,117 @@
 export {};
 
-import type { BunFile, Env, PathLike } from "bun";
-
 declare global {
-	namespace NodeJS {
-		interface ProcessVersions extends Dict<string> {
-			bun: string;
-		}
-		interface ProcessEnv extends Env {}
-	}
+  namespace NodeJS {
+    interface Process {
+      readonly version: string;
+      browser: boolean;
+
+      /**
+       * Whether you are using Bun
+       */
+      isBun: true;
+
+      /**
+       * The current git sha of Bun
+       */
+      revision: string;
+
+      reallyExit(code?: number): never;
+      dlopen(module: { exports: any }, filename: string, flags?: number): void;
+      _exiting: boolean;
+      noDeprecation: boolean;
+
+      binding(m: "constants"): {
+        os: typeof import("node:os").constants;
+        fs: typeof import("node:fs").constants;
+        crypto: typeof import("node:crypto").constants;
+        zlib: typeof import("node:zlib").constants;
+        trace: {
+          TRACE_EVENT_PHASE_BEGIN: number;
+          TRACE_EVENT_PHASE_END: number;
+          TRACE_EVENT_PHASE_COMPLETE: number;
+          TRACE_EVENT_PHASE_INSTANT: number;
+          TRACE_EVENT_PHASE_ASYNC_BEGIN: number;
+          TRACE_EVENT_PHASE_ASYNC_STEP_INTO: number;
+          TRACE_EVENT_PHASE_ASYNC_STEP_PAST: number;
+          TRACE_EVENT_PHASE_ASYNC_END: number;
+          TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: number;
+          TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: number;
+          TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: number;
+          TRACE_EVENT_PHASE_FLOW_BEGIN: number;
+          TRACE_EVENT_PHASE_FLOW_STEP: number;
+          TRACE_EVENT_PHASE_FLOW_END: number;
+          TRACE_EVENT_PHASE_METADATA: number;
+          TRACE_EVENT_PHASE_COUNTER: number;
+          TRACE_EVENT_PHASE_SAMPLE: number;
+          TRACE_EVENT_PHASE_CREATE_OBJECT: number;
+          TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: number;
+          TRACE_EVENT_PHASE_DELETE_OBJECT: number;
+          TRACE_EVENT_PHASE_MEMORY_DUMP: number;
+          TRACE_EVENT_PHASE_MARK: number;
+          TRACE_EVENT_PHASE_CLOCK_SYNC: number;
+          TRACE_EVENT_PHASE_ENTER_CONTEXT: number;
+          TRACE_EVENT_PHASE_LEAVE_CONTEXT: number;
+          TRACE_EVENT_PHASE_LINK_IDS: number;
+        };
+      };
+      binding(m: string): object;
+    }
+
+    interface ProcessVersions extends Dict<string> {
+      bun: string;
+    }
+  }
 }
 
 declare module "fs/promises" {
-	function exists(path: PathLike): Promise<boolean>;
+  function exists(path: Bun.PathLike): Promise<boolean>;
 }
 
 declare module "tls" {
-	interface BunConnectionOptions
-		extends Omit<ConnectionOptions, "key" | "ca" | "tls" | "cert"> {
-		/**
-		 * Optionally override the trusted CA certificates. Default is to trust
-		 * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
-		 * replaced when CAs are explicitly specified using this option.
-		 */
-		ca?:
-			| string
-			| Buffer
-			| NodeJS.TypedArray
-			| BunFile
-			| Array<string | Buffer | BunFile>
-			| undefined;
-		/**
-		 *  Cert chains in PEM format. One cert chain should be provided per
-		 *  private key. Each cert chain should consist of the PEM formatted
-		 *  certificate for a provided private key, followed by the PEM
-		 *  formatted intermediate certificates (if any), in order, and not
-		 *  including the root CA (the root CA must be pre-known to the peer,
-		 *  see ca). When providing multiple cert chains, they do not have to
-		 *  be in the same order as their private keys in key. If the
-		 *  intermediate certificates are not provided, the peer will not be
-		 *  able to validate the certificate, and the handshake will fail.
-		 */
-		cert?:
-			| string
-			| Buffer
-			| NodeJS.TypedArray
-			| BunFile
-			| Array<string | Buffer | NodeJS.TypedArray | BunFile>
-			| undefined;
-		/**
-		 * Private keys in PEM format. PEM allows the option of private keys
-		 * being encrypted. Encrypted keys will be decrypted with
-		 * options.passphrase. Multiple keys using different algorithms can be
-		 * provided either as an array of unencrypted key strings or buffers,
-		 * or an array of objects in the form {pem: <string|buffer>[,
-		 * passphrase: <string>]}. The object form can only occur in an array.
-		 * object.passphrase is optional. Encrypted keys will be decrypted with
-		 * object.passphrase if provided, or options.passphrase if it is not.
-		 */
-		key?:
-			| string
-			| Buffer
-			| BunFile
-			| NodeJS.TypedArray
-			| Array<string | Buffer | BunFile | NodeJS.TypedArray | KeyObject>
-			| undefined;
-	}
+  interface BunConnectionOptions extends Omit<ConnectionOptions, "key" | "ca" | "tls" | "cert"> {
+    /**
+     * Optionally override the trusted CA certificates. Default is to trust
+     * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
+     * replaced when CAs are explicitly specified using this option.
+     */
+    ca?: string | Buffer | NodeJS.TypedArray | Bun.BunFile | Array<string | Buffer | Bun.BunFile> | undefined;
+    /**
+     *  Cert chains in PEM format. One cert chain should be provided per
+     *  private key. Each cert chain should consist of the PEM formatted
+     *  certificate for a provided private key, followed by the PEM
+     *  formatted intermediate certificates (if any), in order, and not
+     *  including the root CA (the root CA must be pre-known to the peer,
+     *  see ca). When providing multiple cert chains, they do not have to
+     *  be in the same order as their private keys in key. If the
+     *  intermediate certificates are not provided, the peer will not be
+     *  able to validate the certificate, and the handshake will fail.
+     */
+    cert?:
+      | string
+      | Buffer
+      | NodeJS.TypedArray
+      | Bun.BunFile
+      | Array<string | Buffer | NodeJS.TypedArray | Bun.BunFile>
+      | undefined;
+    /**
+     * Private keys in PEM format. PEM allows the option of private keys
+     * being encrypted. Encrypted keys will be decrypted with
+     * options.passphrase. Multiple keys using different algorithms can be
+     * provided either as an array of unencrypted key strings or buffers,
+     * or an array of objects in the form {pem: <string|buffer>[,
+     * passphrase: <string>]}. The object form can only occur in an array.
+     * object.passphrase is optional. Encrypted keys will be decrypted with
+     * object.passphrase if provided, or options.passphrase if it is not.
+     */
+    key?:
+      | string
+      | Buffer
+      | Bun.BunFile
+      | NodeJS.TypedArray
+      | Array<string | Buffer | Bun.BunFile | NodeJS.TypedArray | KeyObject>
+      | undefined;
+  }
 
-	function connect(
-		options: BunConnectionOptions,
-		secureConnectListener?: () => void,
-	): TLSSocket;
+  function connect(options: BunConnectionOptions, secureConnectListener?: () => void): TLSSocket;
 }