namespace

bun.__internal

namespace __internal

interface BunEvent
The Node.js-flavored members of the global Event. The global interface picks them up only when lib.dom.d.ts is not loaded: lib.dom declares composedPath(): EventTarget[], which is incompatible with the tuple type below, so when lib.dom is loaded its declarations win.
- readonly bubbles: boolean
  This is not used in Node.js and is provided purely for completeness.
- readonly cancelable: boolean
  True if the event was created with the cancelable option
- cancelBubble: boolean
  Alias for event.stopPropagation(). This is not used in Node.js and is provided purely for completeness.
- readonly composed: boolean
  This is not used in Node.js and is provided purely for completeness.
- readonly currentTarget: null | EventTarget
  Alias for event.target.
- readonly defaultPrevented: boolean
  true if cancelable is true and event.preventDefault() has been called.
- readonly eventPhase: number
  This is not used in Node.js and is provided purely for completeness.
- readonly isTrusted: boolean
  The AbortSignal "abort" event is emitted with isTrusted set to true. The value is false in all other cases.
- returnValue: boolean
  This is not used in Node.js and is provided purely for completeness.
- readonly srcElement: null | EventTarget
  Alias for event.target.
- readonly target: null | EventTarget
  The EventTarget dispatching the event
- readonly timeStamp: number
  The millisecond timestamp when the Event object was created.
- readonly type: string
  The type of event, for example "click", "hashchange", or "submit".
- composedPath(): [EventTarget?];
  Returns an array containing the current EventTarget as the only entry or empty if the event is not being dispatched. This is not used in Node.js and is provided purely for completeness.
- preventDefault(): void;
  Sets the defaultPrevented property to true if cancelable is true.
- stopImmediatePropagation(): void;
  Stops the invocation of event listeners after the current one completes.
- stopPropagation(): void;
  This is not used in Node.js and is provided purely for completeness.
interface BunEventTarget
The Node.js-flavored members of the global EventTarget, used only when lib.dom.d.ts is not loaded, same as BunEvent.
- addEventListener(
  type: string,
  listener: EventListener | EventListenerObject,
  options?: boolean | AddEventListenerOptions
  ): void;
  Adds a new handler for the type event. Any given listener is added only once per type and per capture option value.
  If the once option is true, the listener is removed after the next time a type event is dispatched.
  The capture option is not used by Node.js in any functional way other than tracking registered event listeners per the EventTarget specification. Specifically, the capture option is used as part of the key when registering a listener. Any individual listener may be added once with capture = false, and once with capture = true.
- dispatchEvent(
  event: Event
  ): boolean;
  Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
- removeEventListener(
  type: string,
  listener: EventListener | EventListenerObject,
  options?: boolean | EventListenerOptions
  ): void;
  Removes the event listener in target's event listener list with the same type, callback, and options.
interface BunHeadersOverride
- readonly count: number
  The number of headers.
- getAll(
  name: 'set-cookie' | 'Set-Cookie'
  ): string[];
  Gets all values for the given header name.
  Only "Set-Cookie" is supported. Any other header name returns an empty array.
  @param name
  The header name
  @returns
  The header's values
  const headers = new Headers(); headers.append("Set-Cookie", "foo=bar"); headers.append("Set-Cookie", "baz=qux"); headers.getAll("Set-Cookie"); // ["foo=bar", "baz=qux"]
- toJSON(): Record<string, string> & { set-cookie: string[] };
  Converts Headers to a plain JavaScript object.
  About 10x faster than Object.fromEntries(headers.entries()).
  Called when you run JSON.stringify(headers).
  Does not preserve insertion order. Well-known header names are lowercased; other header names are left as-is.
interface BunRequestOverride
- headers: BunHeadersOverride
- textStream(): ReadableStream<string>;
  Returns a ReadableStream of the body decoded as UTF-8 text.
  Multi-byte characters split across chunk boundaries are joined correctly. Throws a TypeError if the body has already been consumed or is locked.
interface BunResponseOverride
- headers: BunHeadersOverride
- textStream(): ReadableStream<string>;
  Returns a ReadableStream of the body decoded as UTF-8 text.
  Multi-byte characters split across chunk boundaries are joined correctly. Throws a TypeError if the body has already been consumed or is locked.
interface FallbackBody
- arrayBuffer(): Promise<ArrayBuffer>;
- blob(): Promise<Blob>;
- bytes(): Promise<Uint8Array<ArrayBufferLike>>;
- formData(): Promise<FormData>;
- json(): Promise<unknown>;
- text(): Promise<string>;
interface FallbackHeaders
- [Symbol.iterator](): SpecIterableIterator<[string, string]>;
- append(
  name: string,
  value: string
  ): void;
- delete(
  name: string
  ): void;
- entries(): SpecIterableIterator<[string, string]>;
- forEach(
  callbackfn: (value: string, key: string, iterable: Headers) => void,
  thisArg?: unknown
  ): void;
- get(
  name: string
  ): null | string;
- getSetCookie(): string[];
- has(
  name: string
  ): boolean;
- keys(): SpecIterableIterator<string>;
- set(
  name: string,
  value: string
  ): void;
- values(): SpecIterableIterator<string>;
interface FallbackRequest
- readonly body: null | ReadableStream<any>
- readonly bodyUsed: boolean
- readonly cache: RequestCache
- readonly credentials: RequestCredentials
- readonly destination: RequestDestination
- readonly duplex: 'half'
- readonly headers: Headers
- readonly integrity: string
- readonly keepalive: boolean
- readonly method: string
- readonly mode: RequestMode
- readonly redirect: RequestRedirect
- readonly referrer: string
- readonly referrerPolicy: ReferrerPolicy
- readonly signal: AbortSignal
- readonly textStream: () => ReadableStream<string>
- readonly url: string
- arrayBuffer(): Promise<ArrayBuffer>;
- blob(): Promise<Blob>;
- bytes(): Promise<Uint8Array<ArrayBufferLike>>;
- clone(): Request;
- formData(): Promise<FormData>;
- json(): Promise<unknown>;
- text(): Promise<string>;
interface FallbackResponse
- readonly body: null | ReadableStream<any>
- readonly bodyUsed: boolean
- readonly headers: Headers
- readonly ok: boolean
- readonly redirected: boolean
- readonly status: number
- readonly statusText: string
- readonly textStream: () => ReadableStream<string>
- readonly type: ResponseType
- readonly url: string
- arrayBuffer(): Promise<ArrayBuffer>;
- blob(): Promise<Blob>;
- bytes(): Promise<Uint8Array<ArrayBufferLike>>;
- clone(): Response;
- formData(): Promise<FormData>;
- json(): Promise<unknown>;
- text(): Promise<string>;
interface ImportMetaGlob
- glob<TModule = unknown>(
  pattern: string | string[],
  options?: ImportMetaGlobOptions & { eager: false }
  ): Record<string, () => Promise<TModule>>;
  Import every module that matches a glob pattern. Compatible with Vite's import.meta.glob.
  Bun's transpiler and bundler replace the call with an object literal, so the arguments must be literals.
  const pages = import.meta.glob("./pages/*.tsx"); // { // "./pages/about.tsx": () => import("./pages/about.tsx"), // "./pages/home.tsx": () => import("./pages/home.tsx"), // }
  glob<TModule = unknown>(
  pattern: string | string[],
  options: ImportMetaGlobOptions & { eager: true }
  ): Record<string, TModule>;
  const pages = import.meta.glob("./pages/*.tsx", { eager: true }); // import * as about from "./pages/about.tsx"; // import * as home from "./pages/home.tsx"; // { "./pages/about.tsx": about, "./pages/home.tsx": home }
type DistributedMerge<T, Else = T> = T extends T ? Merge<T, Exclude<Else, T>> : never

type DistributedOmit<T, K extends PropertyKey> = T extends T ? Omit<T, K> : never

Like Omit, but correctly distributes over unions. Most useful for removing properties from union options objects, like Bun.SQL.Options

type X = Bun.DistributedOmit<{type?: 'a', url?: string} | {type?: 'b', flag?: boolean}, "url">
// `{type?: 'a'} | {type?: 'b', flag?: boolean}` (Omit applied to each union item instead of entire type)

type X = Omit<{type?: 'a', url?: string} | {type?: 'b', flag?: boolean}, "url">;
// `{type?: "a" | "b" | undefined}` (Missing `flag` property and no longer a union)

type KeysInBoth<A, B> = Extract<keyof A, keyof B>
type LibDomIsLoaded = typeof globalThis extends { onabort: any } ? true : false
type LibEmptyOrBroadcastChannel = LibDomIsLoaded extends true ? {} : BroadcastChannel
type LibEmptyOrBunEvent = LibDomIsLoaded extends true ? {} : BunEvent
type LibEmptyOrBunEventTarget = LibDomIsLoaded extends true ? {} : BunEventTarget
type LibEmptyOrBunWebSocket = LibDomIsLoaded extends true ? {} : Bun.WebSocket
type LibEmptyOrEventSource = LibDomIsLoaded extends true ? {} : EventSource
type LibEmptyOrNodeCryptoWebcryptoSubtleCrypto = LibDomIsLoaded extends true ? {} : webcrypto.SubtleCrypto
type LibEmptyOrNodeMessagePort = LibDomIsLoaded extends true ? {} : MessagePort
type LibEmptyOrNodeReadableStream<T> = LibDomIsLoaded extends true ? {} : ReadableStream
type LibEmptyOrNodeStreamWebCompressionStream = LibDomIsLoaded extends true ? {} : CompressionStream
type LibEmptyOrNodeStreamWebDecompressionStream = LibDomIsLoaded extends true ? {} : DecompressionStream
type LibEmptyOrNodeStreamWebTextDecoderStream = LibDomIsLoaded extends true ? {} : TextDecoderStream
type LibEmptyOrNodeStreamWebTextEncoderStream = LibDomIsLoaded extends true ? {} : TextEncoderStream
type LibEmptyOrNodeUtilTextDecoder = LibDomIsLoaded extends true ? {} : TextDecoder
type LibEmptyOrNodeUtilTextEncoder = LibDomIsLoaded extends true ? {} : TextEncoder
type LibEmptyOrNodeWritableStream<T> = LibDomIsLoaded extends true ? {} : WritableStream
type LibEmptyOrPerformanceEntry = LibDomIsLoaded extends true ? {} : PerformanceEntry
type LibEmptyOrPerformanceMark = LibDomIsLoaded extends true ? {} : PerformanceMark
type LibEmptyOrPerformanceMeasure = LibDomIsLoaded extends true ? {} : PerformanceMeasure
type LibEmptyOrPerformanceObserver = LibDomIsLoaded extends true ? {} : PerformanceObserver
type LibEmptyOrPerformanceObserverEntryList = LibDomIsLoaded extends true ? {} : PerformanceObserverEntryList
type LibEmptyOrPerformanceResourceTiming = LibDomIsLoaded extends true ? {} : PerformanceResourceTiming
type LibEmptyOrReadableByteStreamController = LibDomIsLoaded extends true ? {} : ReadableByteStreamController
type LibEmptyOrReadableStreamBYOBReader = LibDomIsLoaded extends true ? {} : ReadableStreamBYOBReader
type LibEmptyOrReadableStreamBYOBRequest = LibDomIsLoaded extends true ? {} : ReadableStreamBYOBRequest
type LibOrFallbackHeaders = LibDomIsLoaded extends true ? {} : FallbackHeaders
type LibOrFallbackRequest = LibDomIsLoaded extends true ? {} : FallbackRequest
type LibOrFallbackRequestInit = LibDomIsLoaded extends true ? {} : Omit<RequestInit, 'body' | 'headers'> & { body: Bun.BodyInit | null; headers: Bun.HeadersInit }
type LibOrFallbackResponse = LibDomIsLoaded extends true ? {} : FallbackResponse
type LibOrFallbackResponseInit = LibDomIsLoaded extends true ? {} : ResponseInit
type LibPerformanceOrNodePerfHooksPerformance = LibDomIsLoaded extends true ? {} : Performance
type LibWorkerOrBunWorker = LibDomIsLoaded extends true ? {} : Bun.Worker
type Merge<A, B> = MergeInner<A, B> & MergeInner<B, A>
type MergeInner<A, B> = Omit<A, KeysInBoth<A, B>> & Omit<B, KeysInBoth<A, B>> & { [K in KeysInBoth<A, B>]: A[Key] | B[Key] }
type NodeCryptoWebcryptoCryptoKey = webcrypto.CryptoKey
type NodeCryptoWebcryptoCryptoKeyPair = webcrypto.CryptoKeyPair
type UndiciBody = BodyMixin
type UndiciHeaders = Headers
type UseLibDomIfAvailable<GlobalThisKeyName extends PropertyKey, Otherwise> = LibDomIsLoaded extends true ? typeof globalThis extends { [K in GlobalThisKeyName]: infer T } ? T : Otherwise : Otherwise
Uses the lib.dom.d.ts definition of a global if it exists, otherwise falls back to Otherwise.
Some symbols can't be declared in a way that satisfies both @types/bun and lib.dom.d.ts, so when lib.dom.d.ts is loaded, its definition wins.
type Without<A, B> = A & { [K in Exclude<keyof B, keyof A>]: never }
type XOR<A, B> = Without<A, B> | Without<B, A>

bun.__internal

namespace __internal

interface BunEvent

interface BunEventTarget

interface BunHeadersOverride

interface BunRequestOverride

interface BunResponseOverride

interface FallbackBody

interface FallbackHeaders

interface FallbackRequest

interface FallbackResponse

interface ImportMetaGlob