@idlebox/stripe-node-types 24.0.14-patch.0

package/ts5.7/compatibility/float16array.d.ts

@@ -0,0 +1,73 @@
+// Interface declaration for Float16Array, required in @types/node v24+.
+// These definitions are specific to TS 5.7.
+
+// This needs all of the "common" properties/methods of the TypedArrays,
+// otherwise the type unions `TypedArray` and `ArrayBufferView` will be
+// empty objects.
+interface Float16Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
+    readonly BYTES_PER_ELEMENT: number;
+    readonly buffer: TArrayBuffer;
+    readonly byteLength: number;
+    readonly byteOffset: number;
+    readonly length: number;
+    readonly [Symbol.toStringTag]: "Float16Array";
+    at(index: number): number | undefined;
+    copyWithin(target: number, start: number, end?: number): this;
+    entries(): ArrayIterator<[number, number]>;
+    every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean;
+    fill(value: number, start?: number, end?: number): this;
+    filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Float16Array<ArrayBuffer>;
+    find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined;
+    findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number;
+    findLast<S extends number>(
+        predicate: (value: number, index: number, array: this) => value is S,
+        thisArg?: any,
+    ): S | undefined;
+    findLast(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number | undefined;
+    findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
+    forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void;
+    includes(searchElement: number, fromIndex?: number): boolean;
+    indexOf(searchElement: number, fromIndex?: number): number;
+    join(separator?: string): string;
+    keys(): ArrayIterator<number>;
+    lastIndexOf(searchElement: number, fromIndex?: number): number;
+    map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Float16Array<ArrayBuffer>;
+    reduce(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
+    ): number;
+    reduce(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
+        initialValue: number,
+    ): number;
+    reduce<U>(
+        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U,
+        initialValue: U,
+    ): U;
+    reduceRight(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
+    ): number;
+    reduceRight(
+        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
+        initialValue: number,
+    ): number;
+    reduceRight<U>(
+        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U,
+        initialValue: U,
+    ): U;
+    reverse(): this;
+    set(array: ArrayLike<number>, offset?: number): void;
+    slice(start?: number, end?: number): Float16Array<ArrayBuffer>;
+    some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean;
+    sort(compareFn?: (a: number, b: number) => number): this;
+    subarray(begin?: number, end?: number): Float16Array<TArrayBuffer>;
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+    toReversed(): Float16Array<ArrayBuffer>;
+    toSorted(compareFn?: (a: number, b: number) => number): Float16Array<ArrayBuffer>;
+    toString(): string;
+    valueOf(): this;
+    values(): ArrayIterator<number>;
+    with(index: number, value: number): Float16Array<ArrayBuffer>;
+    [Symbol.iterator](): ArrayIterator<number>;
+    [index: number]: number;
+}
+

package/ts5.7/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * License for programmatically and manually incorporated
+ * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc
+ *
+ * Copyright Node.js contributors. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+// NOTE: These definitions support Node.js and TypeScript 5.7.
+
+// Reference required TypeScript libraries:
+/// <reference lib="es2020" />
+/// <reference lib="esnext.disposable" />
+
+// TypeScript library polyfills required for TypeScript 5.7:
+/// <reference path="./compatibility/float16array.d.ts" />
+
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="../compatibility/iterators.d.ts" />
+
+// Definitions for Node.js modules specific to TypeScript 5.7+:
+/// <reference path="../globals.typedarray.d.ts" />
+/// <reference path="../buffer.buffer.d.ts" />
+
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="../globals.d.ts" />
+/// <reference path="../assert.d.ts" />
+/// <reference path="../assert/strict.d.ts" />
+/// <reference path="../async_hooks.d.ts" />
+/// <reference path="../buffer.d.ts" />
+/// <reference path="../child_process.d.ts" />
+/// <reference path="../cluster.d.ts" />
+/// <reference path="../console.d.ts" />
+/// <reference path="../constants.d.ts" />
+/// <reference path="../crypto.d.ts" />
+/// <reference path="../dgram.d.ts" />
+/// <reference path="../diagnostics_channel.d.ts" />
+/// <reference path="../dns.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../domain.d.ts" />
+/// <reference path="../dom-events.d.ts" />
+/// <reference path="../events.d.ts" />
+/// <reference path="../fs.d.ts" />
+/// <reference path="../fs/promises.d.ts" />
+/// <reference path="../http.d.ts" />
+/// <reference path="../http2.d.ts" />
+/// <reference path="../https.d.ts" />
+/// <reference path="../inspector.d.ts" />
+/// <reference path="../module.d.ts" />
+/// <reference path="../net.d.ts" />
+/// <reference path="../os.d.ts" />
+/// <reference path="../path.d.ts" />
+/// <reference path="../perf_hooks.d.ts" />
+/// <reference path="../process.d.ts" />
+/// <reference path="../punycode.d.ts" />
+/// <reference path="../querystring.d.ts" />
+/// <reference path="../readline.d.ts" />
+/// <reference path="../readline/promises.d.ts" />
+/// <reference path="../repl.d.ts" />
+/// <reference path="../sea.d.ts" />
+/// <reference path="../sqlite.d.ts" />
+/// <reference path="../stream.d.ts" />
+/// <reference path="../stream/promises.d.ts" />
+/// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/web.d.ts" />
+/// <reference path="../string_decoder.d.ts" />
+/// <reference path="../test.d.ts" />
+/// <reference path="../timers.d.ts" />
+/// <reference path="../timers/promises.d.ts" />
+/// <reference path="../tls.d.ts" />
+/// <reference path="../trace_events.d.ts" />
+/// <reference path="../tty.d.ts" />
+/// <reference path="../url.d.ts" />
+/// <reference path="../util.d.ts" />
+/// <reference path="../v8.d.ts" />
+/// <reference path="../vm.d.ts" />
+/// <reference path="../wasi.d.ts" />
+/// <reference path="../worker_threads.d.ts" />
+/// <reference path="../zlib.d.ts" />
+
+/// <reference path="../my-shim.d.ts" />

package/tty.d.ts

@@ -0,0 +1,206 @@
+/**
+ * The `node:tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes. In most cases, it will not be necessary or possible to use this module
+ * directly. However, it can be accessed using:
+ *
+ * ```js
+ * import tty from 'node:tty';
+ * ```
+ *
+ * When Node.js detects that it is being run with a text terminal ("TTY")
+ * attached, `process.stdin` will, by default, be initialized as an instance of `tty.ReadStream` and both `process.stdout` and `process.stderr` will, by
+ * default, be instances of `tty.WriteStream`. The preferred method of determining
+ * whether Node.js is being run within a TTY context is to check that the value of
+ * the `process.stdout.isTTY` property is `true`:
+ *
+ * ```console
+ * $ node -p -e "Boolean(process.stdout.isTTY)"
+ * true
+ * $ node -p -e "Boolean(process.stdout.isTTY)" | cat
+ * false
+ * ```
+ *
+ * In most cases, there should be little to no reason for an application to
+ * manually create instances of the `tty.ReadStream` and `tty.WriteStream` classes.
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/tty.js)
+ */
+
+declare module "node:tty" {
+    import * as net from 'node:net';
+    /**
+     * The `tty.isatty()` method returns `true` if the given `fd` is associated with
+     * a TTY and `false` if it is not, including whenever `fd` is not a non-negative
+     * integer.
+     * @since v0.5.8
+     * @param fd A numeric file descriptor
+     */
+    function isatty(fd: number): boolean;
+    /**
+     * Represents the readable side of a TTY. In normal circumstances `process.stdin` will be the only `tty.ReadStream` instance in a Node.js
+     * process and there should be no reason to create additional instances.
+     * @since v0.5.8
+     */
+    class ReadStream extends net.Socket {
+        constructor(fd: number, options?: net.SocketConstructorOpts);
+        /**
+         * A `boolean` that is `true` if the TTY is currently configured to operate as a
+         * raw device.
+         *
+         * This flag is always `false` when a process starts, even if the terminal is
+         * operating in raw mode. Its value will change with subsequent calls to `setRawMode`.
+         * @since v0.7.7
+         */
+        isRaw: boolean;
+        /**
+         * Allows configuration of `tty.ReadStream` so that it operates as a raw device.
+         *
+         * When in raw mode, input is always available character-by-character, not
+         * including modifiers. Additionally, all special processing of characters by the
+         * terminal is disabled, including echoing input
+         * characters. Ctrl+C will no longer cause a `SIGINT` when
+         * in this mode.
+         * @since v0.7.7
+         * @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
+         * property will be set to the resulting mode.
+         * @return The read stream instance.
+         */
+        setRawMode(mode: boolean): this;
+        /**
+         * A `boolean` that is always `true` for `tty.ReadStream` instances.
+         * @since v0.5.8
+         */
+        isTTY: boolean;
+    }
+    /**
+     * -1 - to the left from cursor
+     *  0 - the entire line
+     *  1 - to the right from cursor
+     */
+    type Direction = -1 | 0 | 1;
+    /**
+     * Represents the writable side of a TTY. In normal circumstances, `process.stdout` and `process.stderr` will be the only`tty.WriteStream` instances created for a Node.js process and there
+     * should be no reason to create additional instances.
+     * @since v0.5.8
+     */
+    class WriteStream extends net.Socket {
+        constructor(fd: number);
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "resize", listener: () => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "resize"): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "resize", listener: () => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "resize", listener: () => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "resize", listener: () => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "resize", listener: () => void): this;
+        /**
+         * `writeStream.clearLine()` clears the current line of this `WriteStream` in a
+         * direction identified by `dir`.
+         * @since v0.7.7
+         * @param callback Invoked once the operation completes.
+         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+         */
+        clearLine(dir: Direction, callback?: () => void): boolean;
+        /**
+         * `writeStream.clearScreenDown()` clears this `WriteStream` from the current
+         * cursor down.
+         * @since v0.7.7
+         * @param callback Invoked once the operation completes.
+         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+         */
+        clearScreenDown(callback?: () => void): boolean;
+        /**
+         * `writeStream.cursorTo()` moves this `WriteStream`'s cursor to the specified
+         * position.
+         * @since v0.7.7
+         * @param callback Invoked once the operation completes.
+         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+         */
+        cursorTo(x: number, y?: number, callback?: () => void): boolean;
+        cursorTo(x: number, callback: () => void): boolean;
+        /**
+         * `writeStream.moveCursor()` moves this `WriteStream`'s cursor _relative_ to its
+         * current position.
+         * @since v0.7.7
+         * @param callback Invoked once the operation completes.
+         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+         */
+        moveCursor(dx: number, dy: number, callback?: () => void): boolean;
+        /**
+         * Returns:
+         *
+         * * `1` for 2,
+         * * `4` for 16,
+         * * `8` for 256,
+         * * `24` for 16,777,216 colors supported.
+         *
+         * Use this to determine what colors the terminal supports. Due to the nature of
+         * colors in terminals it is possible to either have false positives or false
+         * negatives. It depends on process information and the environment variables that
+         * may lie about what terminal is used.
+         * It is possible to pass in an `env` object to simulate the usage of a specific
+         * terminal. This can be useful to check how specific environment settings behave.
+         *
+         * To enforce a specific color support, use one of the below environment settings.
+         *
+         * * 2 colors: `FORCE_COLOR = 0` (Disables colors)
+         * * 16 colors: `FORCE_COLOR = 1`
+         * * 256 colors: `FORCE_COLOR = 2`
+         * * 16,777,216 colors: `FORCE_COLOR = 3`
+         *
+         * Disabling color support is also possible by using the `NO_COLOR` and `NODE_DISABLE_COLORS` environment variables.
+         * @since v9.9.0
+         * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
+         */
+        getColorDepth(env?: object): number;
+        /**
+         * Returns `true` if the `writeStream` supports at least as many colors as provided
+         * in `count`. Minimum support is 2 (black and white).
+         *
+         * This has the same false positives and negatives as described in `writeStream.getColorDepth()`.
+         *
+         * ```js
+         * process.stdout.hasColors();
+         * // Returns true or false depending on if `stdout` supports at least 16 colors.
+         * process.stdout.hasColors(256);
+         * // Returns true or false depending on if `stdout` supports at least 256 colors.
+         * process.stdout.hasColors({ TMUX: '1' });
+         * // Returns true.
+         * process.stdout.hasColors(2 ** 24, { TMUX: '1' });
+         * // Returns false (the environment setting pretends to support 2 ** 8 colors).
+         * ```
+         * @since v11.13.0, v10.16.0
+         * @param [count=16] The number of colors that are requested (minimum 2).
+         * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
+         */
+        hasColors(count?: number): boolean;
+        hasColors(env?: object): boolean;
+        hasColors(count: number, env?: object): boolean;
+        /**
+         * `writeStream.getWindowSize()` returns the size of the TTY
+         * corresponding to this `WriteStream`. The array is of the type `[numColumns, numRows]` where `numColumns` and `numRows` represent the number
+         * of columns and rows in the corresponding TTY.
+         * @since v0.7.7
+         */
+        getWindowSize(): [number, number];
+        /**
+         * A `number` specifying the number of columns the TTY currently has. This property
+         * is updated whenever the `'resize'` event is emitted.
+         * @since v0.7.7
+         */
+        columns: number;
+        /**
+         * A `number` specifying the number of rows the TTY currently has. This property
+         * is updated whenever the `'resize'` event is emitted.
+         * @since v0.7.7
+         */
+        rows: number;
+        /**
+         * A `boolean` that is always `true`.
+         * @since v0.5.8
+         */
+        isTTY: boolean;
+    }
+}

package/undici-types/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/undici-types/README.md

@@ -0,0 +1,7 @@
+# undici-types
+
+This package is a dual-publish of the [undici](https://www.npmjs.com/package/undici) library types. The `undici` package **still contains types**. This package is for users who _only_ need undici types (such as for `@types/node`). It is published alongside every release of `undici`, so you can always use the same version.
+
+- [GitHub nodejs/undici](https://github.com/nodejs/undici)
+- [Undici Documentation](https://undici.nodejs.org/#/)
+

package/undici-types/agent.d.ts

@@ -0,0 +1,32 @@
+import { URL } from 'node:url'
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+
+export default Agent
+
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
+  /** `true` after `dispatcher.close()` has been called. */
+  closed: boolean
+  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
+  destroyed: boolean
+  /** Dispatches a request. */
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+}
+
+declare namespace Agent {
+  export interface Options extends Pool.Options {
+    /** Default: `(origin, opts) => new Pool(origin, opts)`. */
+    factory?(origin: string | URL, opts: Object): Dispatcher;
+    /** Integer. Default: `0` */
+    maxRedirections?: number;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+  }
+
+  export interface DispatchOptions extends Dispatcher.DispatchOptions {
+    /** Integer. */
+    maxRedirections?: number;
+  }
+}
+

package/undici-types/api.d.ts

@@ -0,0 +1,44 @@
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
+import Dispatcher from './dispatcher'
+
+/** Performs an HTTP request. */
+declare function request<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData<TOpaque>>
+
+/** A faster version of `request`. */
+declare function stream<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory<TOpaque>
+): Promise<Dispatcher.StreamData<TOpaque>>
+
+/** For easy use with `stream.pipeline`. */
+declare function pipeline<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler<TOpaque>
+): Duplex
+
+/** Starts two-way communications with the requested resource. */
+declare function connect<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
+
+/** Upgrade to a different protocol. */
+declare function upgrade (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}
+

package/undici-types/balanced-pool.d.ts

@@ -0,0 +1,30 @@
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import { URL } from 'node:url'
+
+export default BalancedPool
+
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class BalancedPool extends Dispatcher {
+  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
+
+  addUpstream (upstream: string | URL): BalancedPool
+  removeUpstream (upstream: string | URL): BalancedPool
+  upstreams: Array<string>
+
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+