@depup/stripe 21.0.0-depup.0

package/types/Treasury/Transactions.d.ts

@@ -0,0 +1,202 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace Treasury {
+      /**
+       * Transactions represent changes to a [FinancialAccount's](https://api.stripe.com#financial_accounts) balance.
+       */
+      interface Transaction {
+        /**
+         * Unique identifier for the object.
+         */
+        id: string;
+
+        /**
+         * String representing the object's type. Objects of the same type share the same value.
+         */
+        object: 'treasury.transaction';
+
+        /**
+         * Amount (in cents) transferred.
+         */
+        amount: number;
+
+        /**
+         * Change to a FinancialAccount's balance
+         */
+        balance_impact: Transaction.BalanceImpact;
+
+        /**
+         * Time at which the object was created. Measured in seconds since the Unix epoch.
+         */
+        created: number;
+
+        /**
+         * Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
+         */
+        currency: string;
+
+        /**
+         * An arbitrary string attached to the object. Often useful for displaying to users.
+         */
+        description: string;
+
+        /**
+         * A list of TransactionEntries that are part of this Transaction. This cannot be expanded in any list endpoints.
+         */
+        entries?: ApiList<Stripe.Treasury.TransactionEntry> | null;
+
+        /**
+         * The FinancialAccount associated with this object.
+         */
+        financial_account: string;
+
+        /**
+         * ID of the flow that created the Transaction.
+         */
+        flow: string | null;
+
+        /**
+         * Details of the flow that created the Transaction.
+         */
+        flow_details?: Transaction.FlowDetails | null;
+
+        /**
+         * Type of the flow that created the Transaction.
+         */
+        flow_type: Transaction.FlowType;
+
+        /**
+         * If the object exists in live mode, the value is `true`. If the object exists in test mode, the value is `false`.
+         */
+        livemode: boolean;
+
+        /**
+         * Status of the Transaction.
+         */
+        status: Transaction.Status;
+
+        status_transitions: Transaction.StatusTransitions;
+      }
+
+      namespace Transaction {
+        interface BalanceImpact {
+          /**
+           * The change made to funds the user can spend right now.
+           */
+          cash: number;
+
+          /**
+           * The change made to funds that are not spendable yet, but will become available at a later time.
+           */
+          inbound_pending: number;
+
+          /**
+           * The change made to funds in the account, but not spendable because they are being held for pending outbound flows.
+           */
+          outbound_pending: number;
+        }
+
+        interface FlowDetails {
+          /**
+           * You can reverse some [ReceivedCredits](https://api.stripe.com#received_credits) depending on their network and source flow. Reversing a ReceivedCredit leads to the creation of a new object known as a CreditReversal.
+           */
+          credit_reversal?: Stripe.Treasury.CreditReversal;
+
+          /**
+           * You can reverse some [ReceivedDebits](https://api.stripe.com#received_debits) depending on their network and source flow. Reversing a ReceivedDebit leads to the creation of a new object known as a DebitReversal.
+           */
+          debit_reversal?: Stripe.Treasury.DebitReversal;
+
+          /**
+           * Use [InboundTransfers](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/into/inbound-transfers) to add funds to your [FinancialAccount](https://api.stripe.com#financial_accounts) via a PaymentMethod that is owned by you. The funds will be transferred via an ACH debit.
+           *
+           * Related guide: [Moving money with Treasury using InboundTransfer objects](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/into/inbound-transfers)
+           */
+          inbound_transfer?: Stripe.Treasury.InboundTransfer;
+
+          /**
+           * When an [issued card](https://docs.stripe.com/issuing) is used to make a purchase, an Issuing `Authorization`
+           * object is created. [Authorizations](https://docs.stripe.com/issuing/purchases/authorizations) must be approved for the
+           * purchase to be completed successfully.
+           *
+           * Related guide: [Issued card authorizations](https://docs.stripe.com/issuing/purchases/authorizations)
+           */
+          issuing_authorization?: Stripe.Issuing.Authorization;
+
+          /**
+           * Use [OutboundPayments](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/out-of/outbound-payments) to send funds to another party's external bank account or [FinancialAccount](https://api.stripe.com#financial_accounts). To send money to an account belonging to the same user, use an [OutboundTransfer](https://api.stripe.com#outbound_transfers).
+           *
+           * Simulate OutboundPayment state changes with the `/v1/test_helpers/treasury/outbound_payments` endpoints. These methods can only be called on test mode objects.
+           *
+           * Related guide: [Moving money with Treasury using OutboundPayment objects](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/out-of/outbound-payments)
+           */
+          outbound_payment?: Stripe.Treasury.OutboundPayment;
+
+          /**
+           * Use [OutboundTransfers](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/out-of/outbound-transfers) to transfer funds from a [FinancialAccount](https://api.stripe.com#financial_accounts) to a PaymentMethod belonging to the same entity. To send funds to a different party, use [OutboundPayments](https://api.stripe.com#outbound_payments) instead. You can send funds over ACH rails or through a domestic wire transfer to a user's own external bank account.
+           *
+           * Simulate OutboundTransfer state changes with the `/v1/test_helpers/treasury/outbound_transfers` endpoints. These methods can only be called on test mode objects.
+           *
+           * Related guide: [Moving money with Treasury using OutboundTransfer objects](https://docs.stripe.com/docs/treasury/moving-money/financial-accounts/out-of/outbound-transfers)
+           */
+          outbound_transfer?: Stripe.Treasury.OutboundTransfer;
+
+          /**
+           * ReceivedCredits represent funds sent to a [FinancialAccount](https://api.stripe.com#financial_accounts) (for example, via ACH or wire). These money movements are not initiated from the FinancialAccount.
+           */
+          received_credit?: Stripe.Treasury.ReceivedCredit;
+
+          /**
+           * ReceivedDebits represent funds pulled from a [FinancialAccount](https://api.stripe.com#financial_accounts). These are not initiated from the FinancialAccount.
+           */
+          received_debit?: Stripe.Treasury.ReceivedDebit;
+
+          /**
+           * Type of the flow that created the Transaction. Set to the same value as `flow_type`.
+           */
+          type: FlowDetails.Type;
+        }
+
+        namespace FlowDetails {
+          type Type =
+            | 'credit_reversal'
+            | 'debit_reversal'
+            | 'inbound_transfer'
+            | 'issuing_authorization'
+            | 'other'
+            | 'outbound_payment'
+            | 'outbound_transfer'
+            | 'received_credit'
+            | 'received_debit';
+        }
+
+        type FlowType =
+          | 'credit_reversal'
+          | 'debit_reversal'
+          | 'inbound_transfer'
+          | 'issuing_authorization'
+          | 'other'
+          | 'outbound_payment'
+          | 'outbound_transfer'
+          | 'received_credit'
+          | 'received_debit';
+
+        type Status = 'open' | 'posted' | 'void';
+
+        interface StatusTransitions {
+          /**
+           * Timestamp describing when the Transaction changed status to `posted`.
+           */
+          posted_at: number | null;
+
+          /**
+           * Timestamp describing when the Transaction changed status to `void`.
+           */
+          void_at: number | null;
+        }
+      }
+    }
+  }
+}

package/types/Treasury/TransactionsResource.d.ts

@@ -0,0 +1,82 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace Treasury {
+      interface TransactionRetrieveParams {
+        /**
+         * Specifies which fields in the response should be expanded.
+         */
+        expand?: Array<string>;
+      }
+
+      interface TransactionListParams extends PaginationParams {
+        /**
+         * Returns objects associated with this FinancialAccount.
+         */
+        financial_account: string;
+
+        /**
+         * Only return Transactions that were created during the given date interval.
+         */
+        created?: Stripe.RangeQueryParam | number;
+
+        /**
+         * Specifies which fields in the response should be expanded.
+         */
+        expand?: Array<string>;
+
+        /**
+         * The results are in reverse chronological order by `created` or `posted_at`. The default is `created`.
+         */
+        order_by?: TransactionListParams.OrderBy;
+
+        /**
+         * Only return Transactions that have the given status: `open`, `posted`, or `void`.
+         */
+        status?: TransactionListParams.Status;
+
+        /**
+         * A filter for the `status_transitions.posted_at` timestamp. When using this filter, `status=posted` and `order_by=posted_at` must also be specified.
+         */
+        status_transitions?: TransactionListParams.StatusTransitions;
+      }
+
+      namespace TransactionListParams {
+        type OrderBy = 'created' | 'posted_at';
+
+        type Status = 'open' | 'posted' | 'void';
+
+        interface StatusTransitions {
+          /**
+           * Returns Transactions with `posted_at` within the specified range.
+           */
+          posted_at?: Stripe.RangeQueryParam | number;
+        }
+      }
+
+      class TransactionsResource {
+        /**
+         * Retrieves the details of an existing Transaction.
+         */
+        retrieve(
+          id: string,
+          params?: TransactionRetrieveParams,
+          options?: RequestOptions
+        ): Promise<Stripe.Response<Stripe.Treasury.Transaction>>;
+        retrieve(
+          id: string,
+          options?: RequestOptions
+        ): Promise<Stripe.Response<Stripe.Treasury.Transaction>>;
+
+        /**
+         * Retrieves a list of Transaction objects.
+         */
+        list(
+          params: TransactionListParams,
+          options?: RequestOptions
+        ): ApiListPromise<Stripe.Treasury.Transaction>;
+      }
+    }
+  }
+}

package/types/UpcomingInvoices.d.ts

@@ -0,0 +1,5 @@
+declare module 'stripe' {
+  namespace Stripe {
+    type UpcomingInvoice = Omit<Stripe.Invoice, 'id'>;
+  }
+}

package/types/V2/Billing/MeterEventAdjustments.d.ts

@@ -0,0 +1,65 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        /**
+         * A Meter Event Adjustment is used to cancel or modify previously recorded meter events. Meter Event Adjustments allow you to correct billing data by canceling individual events or event ranges, with tracking of adjustment status and creation time.
+         */
+        interface MeterEventAdjustment {
+          /**
+           * The unique id of this meter event adjustment.
+           */
+          id: string;
+
+          /**
+           * String representing the object's type. Objects of the same type share the same value of the object field.
+           */
+          object: 'v2.billing.meter_event_adjustment';
+
+          /**
+           * Specifies which event to cancel.
+           */
+          cancel: MeterEventAdjustment.Cancel;
+
+          /**
+           * The time the adjustment was created.
+           */
+          created: string;
+
+          /**
+           * The name of the meter event. Corresponds with the `event_name` field on a meter.
+           */
+          event_name: string;
+
+          /**
+           * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+           */
+          livemode: boolean;
+
+          /**
+           * Open Enum. The meter event adjustment's status.
+           */
+          status: MeterEventAdjustment.Status;
+
+          /**
+           * Open Enum. Specifies whether to cancel a single event or a range of events for a time period. Time period cancellation is not supported yet.
+           */
+          type: 'cancel';
+        }
+
+        namespace MeterEventAdjustment {
+          interface Cancel {
+            /**
+             * Unique identifier for the event. You can only cancel events within 24 hours of Stripe receiving them.
+             */
+            identifier: string;
+          }
+
+          type Status = 'complete' | 'pending';
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEventAdjustmentsResource.d.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        interface MeterEventAdjustmentCreateParams {
+          /**
+           * Specifies which event to cancel.
+           */
+          cancel: MeterEventAdjustmentCreateParams.Cancel;
+
+          /**
+           * The name of the meter event. Corresponds with the `event_name` field on a meter.
+           */
+          event_name: string;
+
+          /**
+           * Specifies whether to cancel a single event or a range of events for a time period. Time period cancellation is not supported yet.
+           */
+          type: 'cancel';
+        }
+
+        namespace MeterEventAdjustmentCreateParams {
+          interface Cancel {
+            /**
+             * Unique identifier for the event. You can only cancel events within 24 hours of Stripe receiving them.
+             */
+            identifier: string;
+          }
+        }
+      }
+
+      namespace Billing {
+        class MeterEventAdjustmentsResource {
+          /**
+           * Creates a meter event adjustment to cancel a previously sent meter event.
+           */
+          create(
+            params: MeterEventAdjustmentCreateParams,
+            options?: RequestOptions
+          ): Promise<Stripe.Response<Stripe.V2.Billing.MeterEventAdjustment>>;
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEventSessionResource.d.ts

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        interface MeterEventSessionCreateParams {}
+      }
+
+      namespace Billing {
+        class MeterEventSessionResource {
+          /**
+           * Creates a meter event session to send usage on the high-throughput meter event stream. Authentication tokens are only valid for 15 minutes, so you will need to create a new meter event session when your token expires.
+           */
+          create(
+            params?: MeterEventSessionCreateParams,
+            options?: RequestOptions
+          ): Promise<Stripe.Response<Stripe.V2.Billing.MeterEventSession>>;
+          create(
+            options?: RequestOptions
+          ): Promise<Stripe.Response<Stripe.V2.Billing.MeterEventSession>>;
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEventSessions.d.ts

@@ -0,0 +1,45 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        /**
+         * A Meter Event Session is an authentication session for the high-throughput meter event API. Meter Event Sessions provide temporary authentication tokens with expiration times, enabling secure and efficient bulk submission of usage events.
+         */
+        interface MeterEventSession {
+          /**
+           * The unique id of this auth session.
+           */
+          id: string;
+
+          /**
+           * String representing the object's type. Objects of the same type share the same value of the object field.
+           */
+          object: 'v2.billing.meter_event_session';
+
+          /**
+           * The authentication token for this session.  Use this token when calling the
+           * high-throughput meter event API.
+           */
+          authentication_token: string;
+
+          /**
+           * The creation time of this session.
+           */
+          created: string;
+
+          /**
+           * The time at which this session will expire.
+           */
+          expires_at: string;
+
+          /**
+           * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+           */
+          livemode: boolean;
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEventStreamResource.d.ts

@@ -0,0 +1,62 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        interface MeterEventStreamCreateParams {
+          /**
+           * List of meter events to include in the request. Supports up to 100 events per request.
+           */
+          events: Array<MeterEventStreamCreateParams.Event>;
+        }
+
+        namespace MeterEventStreamCreateParams {
+          interface Event {
+            /**
+             * The name of the meter event. Corresponds with the `event_name` field on a meter.
+             */
+            event_name: string;
+
+            /**
+             * A unique identifier for the event. If not provided, one will be generated.
+             * We recommend using a globally unique identifier for this. We'll enforce
+             * uniqueness within a rolling 24 hour period.
+             */
+            identifier?: string;
+
+            /**
+             * The payload of the event. This must contain the fields corresponding to a meter's
+             * `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and
+             * `value_settings.event_payload_key` (default is `value`). Read more about
+             * the
+             * [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides).
+             */
+            payload: {
+              [key: string]: string;
+            };
+
+            /**
+             * The time of the event. Must be within the past 35 calendar days or up to
+             * 5 minutes in the future. Defaults to current timestamp if not specified.
+             */
+            timestamp?: string;
+          }
+        }
+      }
+
+      namespace Billing {
+        class MeterEventStreamResource {
+          /**
+           * Creates meter events. Events are processed asynchronously, including validation. Requires a meter event session for authentication. Supports up to 10,000 requests per second in livemode. For even higher rate-limits, contact sales.
+           * @throws Stripe.TemporarySessionExpiredError
+           */
+          create(
+            params: MeterEventStreamCreateParams,
+            options?: RequestOptions
+          ): Promise<void>;
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEvents.d.ts

@@ -0,0 +1,55 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        /**
+         * A Meter Event is a usage record that captures billable activity for usage-based billing. Meter Events contain an event name, timestamp, and payload with customer mapping and usage value, enabling accurate usage tracking and billing.
+         */
+        interface MeterEvent {
+          /**
+           * String representing the object's type. Objects of the same type share the same value of the object field.
+           */
+          object: 'v2.billing.meter_event';
+
+          /**
+           * The creation time of this meter event.
+           */
+          created: string;
+
+          /**
+           * The name of the meter event. Corresponds with the `event_name` field on a meter.
+           */
+          event_name: string;
+
+          /**
+           * A unique identifier for the event. If not provided, one will be generated. We recommend using a globally unique identifier for this. We'll enforce uniqueness within a rolling 24 hour period.
+           */
+          identifier: string;
+
+          /**
+           * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+           */
+          livemode: boolean;
+
+          /**
+           * The payload of the event. This must contain the fields corresponding to a meter's
+           * `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and
+           * `value_settings.event_payload_key` (default is `value`). Read more about
+           * the [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides)..
+           */
+          payload: {
+            [key: string]: string;
+          };
+
+          /**
+           * The time of the event. Must be within the past 35 calendar days or up to
+           * 5 minutes in the future. Defaults to current timestamp if not specified.
+           */
+          timestamp: string;
+        }
+      }
+    }
+  }
+}

package/types/V2/Billing/MeterEventsResource.d.ts

@@ -0,0 +1,52 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Billing {
+        interface MeterEventCreateParams {
+          /**
+           * The name of the meter event. Corresponds with the `event_name` field on a meter.
+           */
+          event_name: string;
+
+          /**
+           * The payload of the event. This must contain the fields corresponding to a meter's
+           * `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and
+           * `value_settings.event_payload_key` (default is `value`). Read more about
+           * the
+           * [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides).
+           */
+          payload: {
+            [key: string]: string;
+          };
+
+          /**
+           * A unique identifier for the event. If not provided, one will be generated.
+           * We recommend using a globally unique identifier for this. We'll enforce
+           * uniqueness within a rolling 24 hour period.
+           */
+          identifier?: string;
+
+          /**
+           * The time of the event. Must be within the past 35 calendar days or up to
+           * 5 minutes in the future. Defaults to current timestamp if not specified.
+           */
+          timestamp?: string;
+        }
+      }
+
+      namespace Billing {
+        class MeterEventsResource {
+          /**
+           * Creates a meter event. Events are validated synchronously, but are processed asynchronously. Supports up to 1,000 events per second in livemode. For higher rate-limits, please use meter event streams instead.
+           */
+          create(
+            params: MeterEventCreateParams,
+            options?: RequestOptions
+          ): Promise<Stripe.Response<Stripe.V2.Billing.MeterEvent>>;
+        }
+      }
+    }
+  }
+}