@hasna/connectors 1.3.0 → 1.3.2

package/connectors/connect-yousign/node_modules/bun-types/ffi.d.ts

@@ -0,0 +1,1154 @@
+/**
+ * `bun:ffi` lets you efficiently call C functions & FFI functions from JavaScript
+ *  without writing bindings yourself.
+ *
+ * ```js
+ * import {dlopen, CString, ptr} from 'bun:ffi';
+ *
+ * const lib = dlopen('libsqlite3', {
+ * });
+ * ```
+ *
+ * This is powered by just-in-time compiling C wrappers
+ * that convert JavaScript types to C types and back. Internally,
+ * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks
+ * goes to Fabrice Bellard and TinyCC maintainers for making this possible.
+ *
+ * @category FFI
+ */
+declare module "bun:ffi" {
+  enum FFIType {
+    char = 0,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int8_t = 1,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i8 = 1,
+
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint8_t = 2,
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u8 = 2,
+
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int16_t = 3,
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i16 = 3,
+
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint16_t = 4,
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u16 = 4,
+
+    /**
+     * 32-bit signed integer
+     */
+    int32_t = 5,
+
+    /**
+     * 32-bit signed integer
+     *
+     * Alias of {@link FFIType.int32_t}
+     */
+    i32 = 5,
+    /**
+     * 32-bit signed integer
+     *
+     * The same as `int` in C
+     *
+     * ```c
+     * int
+     * ```
+     */
+    int = 5,
+
+    /**
+     * 32-bit unsigned integer
+     *
+     * The same as `unsigned int` in C (on x64 & arm64)
+     *
+     * C:
+     * ```c
+     * unsigned int
+     * ```
+     * JavaScript:
+     * ```js
+     * ptr(new Uint32Array(1))
+     * ```
+     */
+    uint32_t = 6,
+    /**
+     * 32-bit unsigned integer
+     *
+     * Alias of {@link FFIType.uint32_t}
+     */
+    u32 = 6,
+
+    /**
+     * int64 is a 64-bit signed integer
+     */
+    int64_t = 7,
+    /**
+     * i64 is a 64-bit signed integer
+     */
+    i64 = 7,
+
+    /**
+     * 64-bit unsigned integer
+     */
+    uint64_t = 8,
+    /**
+     * 64-bit unsigned integer
+     */
+    u64 = 8,
+
+    /**
+     * IEEE-754 double precision float
+     */
+    double = 9,
+
+    /**
+     * Alias of {@link FFIType.double}
+     */
+    f64 = 9,
+
+    /**
+     * IEEE-754 single precision float
+     */
+    float = 10,
+
+    /**
+     * Alias of {@link FFIType.float}
+     */
+    f32 = 10,
+
+    /**
+     * Boolean value
+     *
+     * Must be `true` or `false`. `0` and `1` type coercion is not supported.
+     *
+     * In C, this corresponds to:
+     * ```c
+     * bool
+     * _Bool
+     * ```
+     */
+    bool = 11,
+
+    /**
+     * Pointer value
+     *
+     * See {@link Bun.FFI.ptr} for more information
+     *
+     * In C:
+     * ```c
+     * void*
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * ptr(new Uint8Array(1))
+     * ```
+     */
+    ptr = 12,
+    /**
+     * Pointer value
+     *
+     * alias of {@link FFIType.ptr}
+     */
+    pointer = 12,
+
+    /**
+     * void value
+     *
+     * void arguments are not supported
+     *
+     * void return type is the default return type
+     *
+     * In C:
+     * ```c
+     * void
+     * ```
+     */
+    void = 13,
+
+    /**
+     * When used as a `returns`, this will automatically become a {@link CString}.
+     *
+     * When used in `args` it is equivalent to {@link FFIType.pointer}
+     */
+    cstring = 14,
+
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `int64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     */
+    i64_fast = 15,
+
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `uint64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     */
+    u64_fast = 16,
+    function = 17,
+
+    napi_env = 18,
+    napi_value = 19,
+    buffer = 20,
+  }
+
+  type Pointer = number & { __pointer__: null };
+
+  interface FFITypeToArgsType {
+    [FFIType.char]: number;
+    [FFIType.int8_t]: number;
+    [FFIType.i8]: number;
+    [FFIType.uint8_t]: number;
+    [FFIType.u8]: number;
+    [FFIType.int16_t]: number;
+    [FFIType.i16]: number;
+    [FFIType.uint16_t]: number;
+    [FFIType.u16]: number;
+    [FFIType.int32_t]: number;
+    [FFIType.i32]: number;
+    [FFIType.int]: number;
+    [FFIType.uint32_t]: number;
+    [FFIType.u32]: number;
+    [FFIType.int64_t]: number | bigint;
+    [FFIType.i64]: number | bigint;
+    [FFIType.uint64_t]: number | bigint;
+    [FFIType.u64]: number | bigint;
+    [FFIType.double]: number;
+    [FFIType.f64]: number;
+    [FFIType.float]: number;
+    [FFIType.f32]: number;
+    [FFIType.bool]: boolean;
+    [FFIType.ptr]: NodeJS.TypedArray | Pointer | CString | null;
+    [FFIType.pointer]: NodeJS.TypedArray | Pointer | CString | null;
+    [FFIType.void]: undefined;
+    [FFIType.cstring]: NodeJS.TypedArray | Pointer | CString | null;
+    [FFIType.i64_fast]: number | bigint;
+    [FFIType.u64_fast]: number | bigint;
+    [FFIType.function]: Pointer | JSCallback; // cannot be null
+    [FFIType.napi_env]: unknown;
+    [FFIType.napi_value]: unknown;
+    [FFIType.buffer]: NodeJS.TypedArray | DataView;
+  }
+  interface FFITypeToReturnsType {
+    [FFIType.char]: number;
+    [FFIType.int8_t]: number;
+    [FFIType.i8]: number;
+    [FFIType.uint8_t]: number;
+    [FFIType.u8]: number;
+    [FFIType.int16_t]: number;
+    [FFIType.i16]: number;
+    [FFIType.uint16_t]: number;
+    [FFIType.u16]: number;
+    [FFIType.int32_t]: number;
+    [FFIType.i32]: number;
+    [FFIType.int]: number;
+    [FFIType.uint32_t]: number;
+    [FFIType.u32]: number;
+    [FFIType.int64_t]: bigint;
+    [FFIType.i64]: bigint;
+    [FFIType.uint64_t]: bigint;
+    [FFIType.u64]: bigint;
+    [FFIType.double]: number;
+    [FFIType.f64]: number;
+    [FFIType.float]: number;
+    [FFIType.f32]: number;
+    [FFIType.bool]: boolean;
+    [FFIType.ptr]: Pointer | null;
+    [FFIType.pointer]: Pointer | null;
+    [FFIType.void]: undefined;
+    [FFIType.cstring]: CString;
+    [FFIType.i64_fast]: number | bigint;
+    [FFIType.u64_fast]: number | bigint;
+    [FFIType.function]: Pointer | null;
+    [FFIType.napi_env]: unknown;
+    [FFIType.napi_value]: unknown;
+    [FFIType.buffer]: NodeJS.TypedArray | DataView;
+  }
+  interface FFITypeStringToType {
+    ["char"]: FFIType.char;
+    ["int8_t"]: FFIType.int8_t;
+    ["i8"]: FFIType.i8;
+    ["uint8_t"]: FFIType.uint8_t;
+    ["u8"]: FFIType.u8;
+    ["int16_t"]: FFIType.int16_t;
+    ["i16"]: FFIType.i16;
+    ["uint16_t"]: FFIType.uint16_t;
+    ["u16"]: FFIType.u16;
+    ["int32_t"]: FFIType.int32_t;
+    ["i32"]: FFIType.i32;
+    ["int"]: FFIType.int;
+    ["uint32_t"]: FFIType.uint32_t;
+    ["u32"]: FFIType.u32;
+    ["int64_t"]: FFIType.int64_t;
+    ["i64"]: FFIType.i64;
+    ["uint64_t"]: FFIType.uint64_t;
+    ["u64"]: FFIType.u64;
+    ["double"]: FFIType.double;
+    ["f64"]: FFIType.f64;
+    ["float"]: FFIType.float;
+    ["f32"]: FFIType.f32;
+    ["bool"]: FFIType.bool;
+    ["ptr"]: FFIType.ptr;
+    ["pointer"]: FFIType.pointer;
+    ["void"]: FFIType.void;
+    ["cstring"]: FFIType.cstring;
+    ["function"]: FFIType.pointer; // for now
+    ["usize"]: FFIType.uint64_t; // for now
+    ["callback"]: FFIType.pointer; // for now
+    ["napi_env"]: FFIType.napi_env;
+    ["napi_value"]: FFIType.napi_value;
+    ["buffer"]: FFIType.buffer;
+  }
+
+  type FFITypeOrString = FFIType | keyof FFITypeStringToType;
+
+  interface FFIFunction {
+    /**
+     * Arguments to a FFI function (C ABI)
+     *
+     * Defaults to an empty array, which means no arguments.
+     *
+     * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}.
+     *
+     * @example
+     * From JavaScript:
+     * ```ts
+     * import { dlopen, FFIType, suffix } from "bun:ffi"
+     *
+     * const lib = dlopen(`adder.${suffix}`, {
+     * 	add: {
+     * 		// FFIType can be used or you can pass string labels.
+     * 		args: [FFIType.i32, "i32"],
+     * 		returns: "i32",
+     * 	},
+     * })
+     * lib.symbols.add(1, 2)
+     * ```
+     * In C:
+     * ```c
+     * int add(int a, int b) {
+     *   return a + b;
+     * }
+     * ```
+     */
+    readonly args?: readonly FFITypeOrString[];
+    /**
+     * Return type to a FFI function (C ABI)
+     *
+     * Defaults to {@link FFIType.void}
+     *
+     * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}.
+     *
+     * @example
+     * From JavaScript:
+     * ```ts
+     * import { dlopen, CString } from "bun:ffi"
+     *
+     * const lib = dlopen('z', {
+     *    version: {
+     *      returns: "ptr",
+     *   }
+     * });
+     * console.log(new CString(lib.symbols.version()));
+     * ```
+     * In C:
+     * ```c
+     * char* version()
+     * {
+     *  return "1.0.0";
+     * }
+     * ```
+     */
+    readonly returns?: FFITypeOrString;
+
+    /**
+     * Function pointer to the native function
+     *
+     * If provided, instead of using dlsym() to lookup the function, Bun will use this instead.
+     * This pointer should not be null (0).
+     *
+     * This is useful if the library has already been loaded
+     * or if the module is also using Node-API.
+     */
+    readonly ptr?: Pointer | bigint;
+
+    /**
+     * Can C/FFI code call this function from a separate thread?
+     *
+     * Only supported with {@link JSCallback}.
+     *
+     * This does not make the function run in a separate thread. It is still up to the application/library
+     * to run their code in a separate thread.
+     *
+     * By default, {@link JSCallback} calls are not thread-safe. Turning this on
+     * incurs a small performance penalty for every function call. That small
+     * performance penalty needs to be less than the performance gain from
+     * running the function in a separate thread.
+     *
+     * @default false
+     */
+    readonly threadsafe?: boolean;
+  }
+
+  type Symbols = Readonly<Record<string, FFIFunction>>;
+
+  interface Library<Fns extends Symbols> {
+    symbols: ConvertFns<Fns>;
+
+    /**
+     * `dlclose` the library, unloading the symbols and freeing allocated memory.
+     *
+     * Once called, the library is no longer usable.
+     *
+     * Calling a function from a library that has been closed is undefined behavior.
+     */
+    close(): void;
+  }
+
+  type ToFFIType<T extends FFITypeOrString> = T extends FFIType ? T : T extends string ? FFITypeStringToType[T] : never;
+
+  const FFIFunctionCallableSymbol: unique symbol;
+  type ConvertFns<Fns extends Symbols> = {
+    [K in keyof Fns]: {
+      (
+        ...args: Fns[K]["args"] extends infer A extends readonly FFITypeOrString[]
+          ? { [L in keyof A]: FFITypeToArgsType[ToFFIType<A[L]>] }
+          : // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+            [unknown] extends [Fns[K]["args"]]
+            ? []
+            : never
+      ): [unknown] extends [Fns[K]["returns"]] // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+        ? undefined
+        : FFITypeToReturnsType[ToFFIType<NonNullable<Fns[K]["returns"]>>];
+      __ffi_function_callable: typeof FFIFunctionCallableSymbol;
+    };
+  };
+
+  /**
+   * Open a library using `"bun:ffi"`
+   *
+   * @param name The name of the library or file path. This will be passed to `dlopen()`
+   * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction}
+   *
+   * @example
+   *
+   * ```js
+   * import {dlopen} from 'bun:ffi';
+   *
+   * const lib = dlopen("duckdb.dylib", {
+   *   get_version: {
+   *     returns: "cstring",
+   *     args: [],
+   *   },
+   * });
+   * lib.symbols.get_version();
+   * // "1.0.0"
+   * ```
+   *
+   * This is powered by just-in-time compiling C wrappers
+   * that convert JavaScript types to C types and back. Internally,
+   * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks
+   * goes to Fabrice Bellard and TinyCC maintainers for making this possible.
+   *
+   * @category FFI
+   */
+  function dlopen<Fns extends Record<string, FFIFunction>>(
+    name: string | import("bun").BunFile | URL,
+    symbols: Fns,
+  ): Library<Fns>;
+
+  /**
+   * **Experimental:** Compile ISO C11 source code using TinyCC, and make {@link symbols} available as functions to JavaScript.
+   *
+   * @param options
+   * @returns Library<Fns>
+   *
+   * @example
+   * ## Hello, World!
+   *
+   * JavaScript:
+   * ```js
+   * import { cc } from "bun:ffi";
+   * import source from "./hello.c" with {type: "file"};
+   * const {symbols: {hello}} = cc({
+   *   source,
+   *   symbols: {
+   *     hello: {
+   *       returns: "cstring",
+   *       args: [],
+   *     },
+   *   },
+   * });
+   * // "Hello, World!"
+   * console.log(hello());
+   * ```
+   *
+   * `./hello.c`:
+   * ```c
+   * #include <stdio.h>
+   * const char* hello() {
+   *   return "Hello, World!";
+   * }
+   * ```
+   */
+  function cc<Fns extends Record<string, FFIFunction>>(options: {
+    /**
+     * File path to an ISO C11 source file to compile and link
+     */
+    source: string | import("bun").BunFile | URL;
+
+    /**
+     * Library names to link against
+     *
+     * Equivalent to `-l` option in gcc/clang.
+     */
+    library?: string[] | string;
+
+    /**
+     * Include directories to pass to the compiler
+     *
+     * Equivalent to `-I` option in gcc/clang.
+     */
+    include?: string[] | string;
+
+    /**
+     * Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction}
+     */
+    symbols: Fns;
+
+    /**
+     * Map of symbols to define where the key is the symbol name and the value is the symbol value
+     *
+     * Equivalent to `-D` option in gcc/clang.
+     *
+     * @example
+     * ```js
+     * import { cc } from "bun:ffi";
+     * import source from "./hello.c" with {type: "file"};
+     * const {symbols: {hello}} = cc({
+     *   source,
+     *   define: {
+     *     "NDEBUG": "1",
+     *   },
+     *   symbols: {
+     *     hello: {
+     *       returns: "cstring",
+     *       args: [],
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    define?: Record<string, string>;
+
+    /**
+     * Flags to pass to the compiler. Note: we do not make gurantees about which specific version of the compiler is used.
+     *
+     * @default "-std=c11 -Wl,--export-all-symbols -g -O2"
+     *
+     * This is useful for passing macOS frameworks to link against. Or if there are other options you want to pass to the compiler.
+     *
+     * @example
+     * ```js
+     * import { cc } from "bun:ffi";
+     * import source from "./hello.c" with {type: "file"};
+     * const {symbols: {hello}} = cc({
+     *   source,
+     *   flags: ["-framework CoreFoundation", "-framework Security"],
+     *   symbols: {
+     *     hello: {
+     *       returns: "cstring",
+     *       args: [],
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    flags?: string | string[];
+  }): Library<Fns>;
+
+  /**
+   * Turn a native library's function pointer into a JavaScript function
+   *
+   * Libraries using Node-API & bun:ffi in the same module could use this to skip an extra dlopen() step.
+   *
+   * @param fn {@link FFIFunction} declaration. `ptr` is required
+   *
+   * @example
+   *
+   * ```js
+   * import {CFunction} from 'bun:ffi';
+   *
+   * const getVersion = new CFunction({
+   *   returns: "cstring",
+   *   args: [],
+   *   ptr: myNativeLibraryGetVersion,
+   * });
+   * getVersion();
+   * getVersion.close();
+   * ```
+   *
+   * This is powered by just-in-time compiling C wrappers
+   * that convert JavaScript types to C types and back. Internally,
+   * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks
+   * goes to Fabrice Bellard and TinyCC maintainers for making this possible.
+   */
+  function CFunction(fn: FFIFunction & { ptr: Pointer }): CallableFunction & {
+    /**
+     * Free the memory allocated by the wrapping function
+     */
+    close(): void;
+  };
+
+  /**
+   * Link a map of symbols to JavaScript functions
+   *
+   * This lets you use native libraries that were already loaded somehow. You usually will want {@link dlopen} instead.
+   *
+   * You could use this with Node-API to skip loading a second time.
+   *
+   * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction}
+   *
+   * @example
+   *
+   * ```js
+   * import { linkSymbols } from "bun:ffi";
+   *
+   * const [majorPtr, minorPtr, patchPtr] = getVersionPtrs();
+   *
+   * const lib = linkSymbols({
+   *   // Unlike with dlopen(), the names here can be whatever you want
+   *   getMajor: {
+   *     returns: "cstring",
+   *     args: [],
+   *
+   *     // Since this doesn't use dlsym(), you have to provide a valid ptr
+   *     // That ptr could be a number or a bigint
+   *     // An invalid pointer will crash your program.
+   *     ptr: majorPtr,
+   *   },
+   *   getMinor: {
+   *     returns: "cstring",
+   *     args: [],
+   *     ptr: minorPtr,
+   *   },
+   *   getPatch: {
+   *     returns: "cstring",
+   *     args: [],
+   *     ptr: patchPtr,
+   *   },
+   * });
+   *
+   * const [major, minor, patch] = [
+   *   lib.symbols.getMajor(),
+   *   lib.symbols.getMinor(),
+   *   lib.symbols.getPatch(),
+   * ];
+   * ```
+   *
+   * This is powered by just-in-time compiling C wrappers
+   * that convert JavaScript types to C types and back. Internally,
+   * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks
+   * goes to Fabrice Bellard and TinyCC maintainers for making this possible.
+   */
+  function linkSymbols<Fns extends Record<string, FFIFunction>>(symbols: Fns): Library<Fns>;
+
+  /**
+   * Read a pointer as a {@link Buffer}
+   *
+   * If `byteLength` is not provided, the pointer is assumed to be 0-terminated.
+   *
+   * @param ptr The memory address to read
+   * @param byteOffset bytes to skip before reading
+   * @param byteLength bytes to read
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   */
+  function toBuffer(ptr: Pointer, byteOffset?: number, byteLength?: number): Buffer;
+
+  /**
+   * Read a pointer as an {@link ArrayBuffer}
+   *
+   * If `byteLength` is not provided, the pointer is assumed to be 0-terminated.
+   *
+   * @param ptr The memory address to read
+   * @param byteOffset bytes to skip before reading
+   * @param byteLength bytes to read
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   */
+  function toArrayBuffer(ptr: Pointer, byteOffset?: number, byteLength?: number): ArrayBuffer;
+
+  namespace read {
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function u8(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function i8(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function u16(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function i16(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function u32(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function i32(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function f32(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function u64(ptr: Pointer, byteOffset?: number): bigint;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function i64(ptr: Pointer, byteOffset?: number): bigint;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function f64(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function ptr(ptr: Pointer, byteOffset?: number): number;
+    /**
+     * The read function behaves similarly to DataView,
+     * but it's usually faster because it doesn't need to create a DataView or ArrayBuffer.
+     *
+     * @param ptr The memory address to read
+     * @param byteOffset bytes to skip before reading
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    function intptr(ptr: Pointer, byteOffset?: number): number;
+  }
+
+  /**
+   * Get the pointer backing a {@link TypedArray} or {@link ArrayBuffer}
+   *
+   * Use this to pass {@link TypedArray} or {@link ArrayBuffer} to C functions.
+   *
+   * This is for use with FFI functions. For performance reasons, FFI will
+   * not automatically convert typed arrays to C pointers.
+   *
+   * @param {TypedArray|ArrayBuffer|DataView} view the typed array or array buffer to get the pointer for
+   * @param {number} byteOffset optional offset into the view in bytes
+   *
+   * @example
+   *
+   * From JavaScript:
+   * ```js
+   * const array = new Uint8Array(10);
+   * const rawPtr = ptr(array);
+   * myFFIFunction(rawPtr);
+   * ```
+   * To C:
+   * ```c
+   * void myFFIFunction(char* rawPtr) {
+   *  // Do something with rawPtr
+   * }
+   * ```
+   *
+   * @category FFI
+   */
+  function ptr(view: NodeJS.TypedArray | ArrayBufferLike | DataView, byteOffset?: number): Pointer;
+
+  /**
+   * Get a string from a UTF-8 encoded C string
+   * If `byteLength` is not provided, the string is assumed to be null-terminated.
+   *
+   * @example
+   * ```js
+   * var ptr = lib.symbols.getVersion();
+   * console.log(new CString(ptr));
+   * ```
+   *
+   * @example
+   * ```js
+   * var ptr = lib.symbols.getVersion();
+   * // print the first 4 characters
+   * console.log(new CString(ptr, 0, 4));
+   * ```
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   *
+   * @category FFI
+   */
+  class CString extends String {
+    /**
+     * Get a string from a UTF-8 encoded C string
+     * If `byteLength` is not provided, the string is assumed to be null-terminated.
+     *
+     * @param ptr The pointer to the C string
+     * @param byteOffset bytes to skip before reading
+     * @param byteLength bytes to read
+     *
+     * @example
+     * ```js
+     * var ptr = lib.symbols.getVersion();
+     * console.log(new CString(ptr));
+     * ```
+     *
+     * @example
+     * ```js
+     * var ptr = lib.symbols.getVersion();
+     * // print the first 4 characters
+     * console.log(new CString(ptr, 0, 4));
+     * ```
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    constructor(ptr: Pointer, byteOffset?: number, byteLength?: number);
+
+    /**
+     * The ptr to the C string
+     *
+     * This `CString` instance is a clone of the string, so it
+     * is safe to continue using this instance after the `ptr` has been
+     * freed.
+     */
+    ptr: Pointer;
+    byteOffset?: number;
+    byteLength?: number;
+
+    /**
+     * Get the {@link ptr} as an `ArrayBuffer`
+     *
+     * `null` or empty ptrs returns an `ArrayBuffer` with `byteLength` 0
+     */
+    get arrayBuffer(): ArrayBuffer;
+  }
+
+  /**
+   * Pass a JavaScript function to FFI (Foreign Function Interface)
+   */
+  class JSCallback {
+    /**
+     * Enable a JavaScript callback function to be passed to C with bun:ffi
+     *
+     * @param callback The JavaScript function to be called
+     * @param definition The C function definition
+     */
+    constructor(callback: (...args: any[]) => any, definition: FFIFunction);
+
+    /**
+     * The pointer to the C function
+     *
+     * Becomes `null` once {@link JSCallback.prototype.close} is called
+     */
+    readonly ptr: Pointer | null;
+
+    /**
+     * Can the callback be called from a different thread?
+     */
+    readonly threadsafe: boolean;
+
+    /**
+     * Free the memory allocated for the callback
+     *
+     * If called multiple times, does nothing after the first call.
+     */
+    close(): void;
+  }
+
+  /**
+   * View the generated C code for FFI bindings
+   *
+   * You probably won't need this unless there's a bug in the FFI bindings
+   * generator or you're just curious.
+   */
+  function viewSource(symbols: Symbols, is_callback?: false): string[];
+  function viewSource(callback: FFIFunction, is_callback: true): string;
+
+  /**
+   * Platform-specific file extension name for dynamic libraries
+   *
+   * "." is not included
+   *
+   * @example
+   * ```js
+   * "dylib" // macOS
+   * ```
+   *
+   * @example
+   * ```js
+   * "so" // linux
+   * ```
+   */
+  const suffix: string;
+}