@depup/stripe 21.0.0-depup.0

package/types/lib.d.ts

@@ -0,0 +1,420 @@
+///<reference lib="esnext.asynciterable" />
+/// <reference types="node" />
+
+import {Agent} from 'http';
+
+import {ApiVersion} from './apiVersion';
+
+declare module 'stripe' {
+  namespace Stripe {
+    type StripeResourceClass = typeof StripeResource;
+
+    interface StripeResourceExtension<T extends object>
+      extends StripeResourceClass {
+      new (stripe: Stripe): StripeResource & T;
+    }
+
+    export class StripeResource {
+      static extend<
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        T extends {[prop: string]: any}
+      >(spec: T): StripeResourceExtension<T>;
+      static method<ResponseObject = object>(spec: {
+        method: string;
+        path?: string;
+        fullPath?: string;
+        // Please note, methodType === 'search' is beta functionality and is subject to
+        // change/removal at any time.
+        methodType?: 'list' | 'search';
+      }): (...args: any[]) => Response<ResponseObject>; //eslint-disable-line @typescript-eslint/no-explicit-any
+      static MAX_BUFFERED_REQUEST_METRICS: number;
+    }
+    export type LatestApiVersion = typeof ApiVersion;
+    export const API_VERSION: string;
+    export type HttpAgent = Agent;
+    export type HttpProtocol = 'http' | 'https';
+
+    export interface StripeConfig {
+      /**
+       * This library's types only reflect the latest API version.
+       *
+       * We recommend upgrading your account's API Version to the latest version
+       * if you wish to use TypeScript with this library.
+       *
+       * If you wish to remain on your account's default API version,
+       * you may pass `null` or another version instead of the latest version,
+       * and add a `@ts-ignore` comment here and anywhere the types differ between API versions.
+       *
+       * @docs https://stripe.com/docs/api/versioning
+       */
+      apiVersion?: LatestApiVersion;
+
+      /**
+       * Optionally indicate that you are using TypeScript.
+       * This currently has no runtime effect other than adding "TypeScript" to your user-agent.
+       */
+      typescript?: true;
+
+      /**
+       * Specifies maximum number of automatic network retries (default 1).
+       * Retries will be attempted with exponential backoff.
+       * Retries can be disabled by setting this option to 0.
+       * [Idempotency keys](https://stripe.com/docs/api/idempotent_requests) are added where appropriate to prevent duplication.
+       * @docs https://github.com/stripe/stripe-node#network-retries
+       */
+      maxNetworkRetries?: number;
+
+      /**
+       * Use a custom http(s) agent.
+       * Useful for making requests through a proxy.
+       */
+      httpAgent?: HttpAgent;
+
+      /**
+       * Use a custom http client, rather than relying on Node libraries.
+       * Useful for making requests in contexts other than NodeJS (eg. using
+       * `fetch`).
+       */
+      httpClient?: HttpClient;
+
+      /**
+       * Request timeout in milliseconds.
+       * The default is 80000
+       */
+      timeout?: number;
+
+      /**
+       * Specify the host to use for API Requests.
+       */
+      host?: string;
+
+      /**
+       * Specify the port to use for API Requests.
+       */
+      port?: string | number;
+
+      /**
+       * Specify the HTTP protool to use for API Requests.
+       */
+      protocol?: HttpProtocol;
+
+      /**
+       * Pass `telemetry: false` to disable headers that provide Stripe
+       * with data about usage of the API.
+       * Currently, the only telemetry we send is latency metrics.
+       */
+      telemetry?: boolean;
+
+      /**
+       * For plugin authors to identify their code.
+       * @docs https://stripe.com/docs/building-plugins?lang=node#setappinfo
+       */
+      appInfo?: AppInfo;
+
+      /**
+       * An account id on whose behalf you wish to make every request. Prefer `stripeContext` for new code.
+       */
+      stripeAccount?: string;
+
+      /**
+       * An account on whose behalf you wish to make every request. See https://docs.corp.stripe.com/context for more information.
+       */
+      stripeContext?: string | StripeContext;
+    }
+
+    export interface RequestOptions {
+      /**
+       * Use a specific API Key for this request.
+       * For Connect, we recommend using `stripeAccount` instead.
+       */
+      apiKey?: string;
+
+      /**
+       * See the [idempotency key docs](https://stripe.com/docs/api/idempotent_requests).
+       */
+      idempotencyKey?: string;
+
+      /**
+       * An account id on whose behalf you wish to make a request. Prefer `stripeContext` for new code.
+       */
+      stripeAccount?: string;
+
+      /**
+       * An account on whose behalf you wish to make a request. See https://docs.corp.stripe.com/context for more information.
+       */
+      stripeContext?: string | StripeContext;
+
+      /**
+       * The [API Version](https://stripe.com/docs/upgrades) to use for a given request (e.g., '2020-03-02').
+       */
+      apiVersion?: string;
+
+      /**
+       * Specify the number of requests to retry in event of error.
+       * This overrides a default set on the Stripe object's config argument.
+       */
+      maxNetworkRetries?: number;
+
+      /**
+       * Specify a timeout for this request in milliseconds.
+       */
+      timeout?: number;
+
+      /**
+       * Specify the host for this request.
+       */
+      host?: string;
+    }
+
+    export type RawRequestOptions = RequestOptions & {
+      /**
+       * Specify additional request headers. This is an experimental interface and is not yet stable.
+       */
+      additionalHeaders?: {[headerName: string]: string};
+    };
+
+    export type Response<T> = T & {
+      lastResponse: {
+        headers: {[key: string]: string};
+        requestId: string;
+        statusCode: number;
+        apiVersion?: string;
+        idempotencyKey?: string;
+        stripeAccount?: string;
+      };
+    };
+
+    /**
+     * A container for paginated lists of objects.
+     * The array of objects is on the `.data` property,
+     * and `.has_more` indicates whether there are additional objects beyond the end of this list.
+     *
+     * Learn more in Stripe's [pagination docs](https://stripe.com/docs/api/pagination?lang=node)
+     * or, when iterating over many items, try [auto-pagination](https://github.com/stripe/stripe-node#auto-pagination) instead.
+     */
+    export interface ApiList<T> {
+      object: 'list';
+
+      data: Array<T>;
+
+      /**
+       * True if this list has another page of items after this one that can be fetched.
+       */
+      has_more: boolean;
+
+      /**
+       * The URL where this list can be accessed.
+       */
+      url: string;
+
+      // Looking for `total_count`? It is deprecated; please do not use it.
+    }
+
+    export interface ApiListPromise<T>
+      extends Promise<Response<ApiList<T>>>,
+        AsyncIterableIterator<T> {
+      autoPagingEach(
+        handler: (item: T) => boolean | void | Promise<boolean | void>,
+        onDone?: (err: any) => void
+      ): Promise<void>;
+
+      autoPagingToArray(
+        opts: {limit: number},
+        onDone?: (err: any) => void
+      ): Promise<Array<T>>;
+    }
+
+    /**
+     * A container for paginated lists of search results.
+     * The array of objects is on the `.data` property,
+     * and `.has_more` indicates whether there are additional objects beyond the end of this list.
+     * The `.next_page` field can be used to paginate forwards.
+     *
+     * Please note, ApiSearchResult<T> is beta functionality and is subject to change/removal
+     * at any time.
+     */
+    export interface ApiSearchResult<T> {
+      object: 'search_result';
+
+      data: Array<T>;
+
+      /**
+       * True if this list has another page of items after this one that can be fetched.
+       */
+      has_more: boolean;
+
+      /**
+       * The URL where this list can be accessed.
+       */
+      url: string;
+
+      /**
+       * The page token to use to get the next page of results. If `has_more` is
+       * true, this will be set to a concrete string value.
+       */
+      next_page: string | null;
+
+      /**
+       * The total number of search results. Only present when `expand` request
+       * parameter contains `total_count`.
+       */
+      total_count?: number;
+    }
+    export interface ApiSearchResultPromise<T>
+      extends Promise<Response<ApiSearchResult<T>>>,
+        AsyncIterableIterator<T> {
+      autoPagingEach(
+        handler: (item: T) => boolean | void | Promise<boolean | void>
+      ): Promise<void>;
+
+      autoPagingToArray(opts: {limit: number}): Promise<Array<T>>;
+    }
+
+    export type StripeStreamResponse = NodeJS.ReadableStream;
+
+    /**
+     * The Stripe API uses url-encoding for requests, and stripe-node encodes a
+     * `null` param as an empty string, because there is no concept of `null`
+     * in url-encoding. Both `null` and `''` behave identically.
+     */
+    export type Emptyable<T> = null | '' | T;
+
+    export interface RequestEvent {
+      api_version: string;
+      account?: string;
+      idempotency_key?: string;
+      method: string;
+      path: string;
+      request_start_time: number;
+    }
+
+    export interface ResponseEvent {
+      api_version: string;
+      account?: string;
+      idempotency_key?: string;
+      method: string;
+      path: string;
+      status: number;
+      request_id: string;
+      elapsed: number;
+      request_start_time: number;
+      request_end_time: number;
+    }
+
+    /**
+     * Identify your plugin.
+     * @docs https://stripe.com/docs/building-plugins?lang=node#setappinfo
+     */
+    export interface AppInfo {
+      name: string;
+      partner_id?: string;
+      url?: string;
+      version?: string;
+    }
+
+    export interface FileData {
+      data: string | Buffer | Uint8Array;
+      name?: string;
+      type?: string;
+    }
+
+    /**
+     * Rounding direction for Decimal operations (IEEE 754-2019 §4.3).
+     */
+    type RoundDirection =
+      | 'ceil'
+      | 'floor'
+      | 'round-down'
+      | 'round-up'
+      | 'half-up'
+      | 'half-down'
+      | 'half-even';
+
+    /**
+     * Precision specification for {@link Decimal.round}.
+     */
+    interface DecimalRoundingOptions {
+      mode: 'decimal-places' | 'significant-figures';
+      value: number;
+    }
+
+    /**
+     * Built-in rounding presets accepted by {@link Decimal.round}.
+     * Extensible via declaration merging.
+     */
+    interface DecimalRoundingPresets {
+      'ubb-usage-count': DecimalRoundingOptions;
+      'v1-api': DecimalRoundingOptions;
+    }
+
+    /**
+     * IEEE 754 decimal128 coefficient size (34 digits) — the recommended
+     * precision for {@link Decimal.div} when full precision is desired.
+     */
+    const DEFAULT_DIV_PRECISION: 34;
+
+    /**
+     * Check whether a value is a {@link Decimal} instance.
+     */
+    function isDecimal(value: unknown): value is Stripe.Decimal;
+
+    /**
+     * Arbitrary-precision decimal number for working with Stripe decimal_string fields
+     * without floating-point precision loss.
+     *
+     * Use `Decimal.from(value)` to construct instances. Instances are immutable.
+     *
+     * @example
+     * import { Decimal } from 'stripe';
+     * const price = Decimal.from("99.99");
+     * const tax = Decimal.from("0.08");
+     * const total = price.mul(tax.add(Decimal.from("1")));
+     */
+    interface Decimal {
+      add(other: Decimal): Decimal;
+      sub(other: Decimal): Decimal;
+      mul(other: Decimal): Decimal;
+      div(
+        other: Decimal,
+        precision: number,
+        direction: Stripe.RoundDirection
+      ): Decimal;
+      cmp(other: Decimal): -1 | 0 | 1;
+      eq(other: Decimal): boolean;
+      lt(other: Decimal): boolean;
+      lte(other: Decimal): boolean;
+      gt(other: Decimal): boolean;
+      gte(other: Decimal): boolean;
+      isZero(): boolean;
+      isNegative(): boolean;
+      isPositive(): boolean;
+      neg(): Decimal;
+      abs(): Decimal;
+      round(
+        direction: Stripe.RoundDirection,
+        options:
+          | keyof Stripe.DecimalRoundingPresets
+          | Stripe.DecimalRoundingOptions
+      ): Decimal;
+      toFixed(decimalPlaces: number, direction: Stripe.RoundDirection): string;
+      toNumber(): number;
+      toString(): string;
+      toJSON(): string;
+      valueOf(): string;
+    }
+    namespace Decimal {
+      function from(value: string | number | bigint): Stripe.Decimal;
+      const zero: Stripe.Decimal;
+    }
+
+    namespace V2 {
+      /**
+       * Represents a monetary amount with associated currency
+       */
+      export interface Amount {
+        value: number;
+        currency: string;
+      }
+    }
+  }
+}

package/types/net/net.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+
+import {IncomingMessage} from 'http';
+declare module 'stripe' {
+  namespace Stripe {
+    /**
+     * Encapsulates the logic for issuing a request to the Stripe API. This is
+     * an experimental interface and is not yet stable.
+     */
+    export interface HttpClient<
+      ResponseType extends HttpClientResponse = HttpClientResponse
+    > {
+      /** The client name to use for diagnostics. */
+      getClientName(): string;
+
+      makeRequest(
+        host: string,
+        port: string | number,
+        path: string,
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+        // object is used here as this is implementation-specific. This is
+        // generally {[key: string]: string}, but various underlying clients
+        // support other types as well. As examples:
+        // - Node supports {[key: string]: string | number | string[]}.
+        // - Fetch supports a Headers object.
+        headers: object,
+        requestData: string | null,
+        protocol: Stripe.HttpProtocol,
+        timeout: number
+      ): Promise<ResponseType>;
+    }
+
+    /**
+     * Abstract representation of an HTTP response. This is an experimental
+     * interface and is not yet stable.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    interface HttpClientResponse<RawResponseType = any, StreamType = any> {
+      /** The numeric HTTP status code for the response. */
+      getStatusCode(): number;
+
+      /** The response headers. */
+      getHeaders(): {[key: string]: string};
+
+      /** This returns the underlying raw response object for the client. */
+      getRawResponse(): RawResponseType;
+
+      /**
+       * This returns the content as a stream. The expectation is that content
+       * will not have been buffered into memory at this point by the client.
+       *
+       * The streamCompleteCallback should be invoked by the response
+       * implementation when the stream has been consumed.
+       */
+      toStream(streamCompleteCallback: () => void): StreamType;
+
+      /**
+       * Converts the response content into a JSON object, failing if JSON
+       * couldn't be parsed.
+       */
+      toJSON(): Promise<object>;
+    }
+
+    export const createNodeHttpClient: (
+      agent?: HttpAgent | null
+    ) => HttpClient<
+      HttpClientResponse<IncomingMessage, Stripe.StripeStreamResponse>
+    >;
+
+    /**
+     * Creates an HTTP client for issuing Stripe API requests which uses the Web
+     * Fetch API.
+     *
+     * A fetch function can optionally be passed in as a parameter. If none is
+     * passed, will default to the default `fetch` function in the global scope.
+     */
+    export const createFetchHttpClient: (
+      /** When specified, interface should match the Web Fetch API function. */
+      fetchFn?: Function
+    ) => HttpClient<
+      HttpClientResponse<
+        /**
+         * The response type cannot be specified without pulling in DOM types.
+         * This corresponds to ReturnType<WindowOrWorkerGlobalScope['fetch']>
+         * for applications which pull in DOM types.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        any,
+        /**
+         * The stream type cannot be specified without pulling in DOM types.
+         * This corresponds to ReadableStream<Uint8Array> for applications which
+         * pull in DOM types.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        any
+      >
+    >;
+  }
+}

package/types/shared.d.ts

@@ -0,0 +1,178 @@
+declare module 'stripe' {
+  namespace Stripe {
+    /**
+     * Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
+     */
+    interface Metadata {
+      [name: string]: string;
+    }
+
+    /**
+     * Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
+     * While you can send values as numbers, they will be returned as strings.
+     */
+    interface MetadataParam {
+      [name: string]: string | number | null;
+    }
+
+    /**
+     * The Address object.
+     */
+    interface Address {
+      /**
+       * City/District/Suburb/Town/Village.
+       */
+      city: string | null;
+
+      /**
+       * 2-letter country code.
+       */
+      country: string | null;
+
+      /**
+       * Address line 1 (Street address/PO Box/Company name).
+       */
+      line1: string | null;
+
+      /**
+       * Address line 2 (Apartment/Suite/Unit/Building).
+       */
+      line2: string | null;
+
+      /**
+       * ZIP or postal code.
+       */
+      postal_code: string | null;
+
+      /**
+       * State/County/Province/Region.
+       */
+      state: string | null;
+    }
+
+    interface JapanAddress {
+      /**
+       * City/Ward.
+       */
+      city: string | null;
+
+      /**
+       * Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)).
+       */
+      country: string | null;
+
+      /**
+       * Block/Building number.
+       */
+      line1: string | null;
+
+      /**
+       * Building details.
+       */
+      line2: string | null;
+
+      /**
+       * Zip/Postal Code.
+       */
+      postal_code: string | null;
+
+      /**
+       * Prefecture.
+       */
+      state: string | null;
+
+      /**
+       * Town/cho-me.
+       */
+      town: string | null;
+    }
+
+    interface AddressParam {
+      /**
+       * City, district, suburb, town, village, or ward.
+       */
+      city?: string;
+
+      /**
+       * Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)).
+       */
+      country?: string;
+
+      /**
+       * Address line 1 (e.g., street, block, PO Box, or company name).
+       */
+      line1?: string;
+
+      /**
+       * Address line 2 (e.g., apartment, suite, unit, or building).
+       */
+      line2?: string;
+
+      /**
+       * ZIP or postal code.
+       */
+      postal_code?: string;
+
+      /**
+       * State, county, province, prefecture, or region.
+       */
+      state?: string;
+    }
+
+    interface ShippingAddressParam extends AddressParam {
+      /**
+       * Address line 1 (e.g., street, PO Box, or company name).
+       */
+      line1: string;
+    }
+
+    interface JapanAddressParam extends AddressParam {
+      /**
+       * Town or cho-me.
+       */
+      town?: string;
+    }
+
+    interface RangeQueryParam {
+      /**
+       * Minimum value to filter by (exclusive)
+       */
+      gt?: number;
+
+      /**
+       * Minimum value to filter by (inclusive)
+       */
+      gte?: number;
+
+      /**
+       * Maximum value to filter by (exclusive)
+       */
+      lt?: number;
+
+      /**
+       * Maximum value to filter by (inclusive)
+       */
+      lte?: number;
+    }
+
+    /**
+     * @docs https://stripe.com/docs/api/pagination
+     */
+    interface PaginationParams {
+      /**
+       * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+       */
+      ending_before?: string;
+
+      /**
+       * A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+       */
+      limit?: number;
+
+      /**
+       * A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+       */
+      starting_after?: string;
+    }
+  }
+}

package/types/test/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: '../.eslintrc.js',
+  rules: {
+    '@typescript-eslint/ban-ts-comment': 0,
+  },
+};