stripe 22.2.0 → 22.3.0-alpha.2

package/cjs/resources/V2/MoneyManagement/OutboundTransfers.d.ts

@@ -0,0 +1,342 @@
+import { StripeResource } from '../../../StripeResource.js';
+import { V2Amount } from './../V2Amounts.js';
+import { MetadataParam, Metadata } from '../../../shared.js';
+import { RequestOptions, V2ListPromise, Response } from '../../../lib.js';
+export declare class OutboundTransferResource extends StripeResource {
+    /**
+     * Returns a list of OutboundTransfers that match the provided filters.
+     */
+    list(params?: V2.MoneyManagement.OutboundTransferListParams, options?: RequestOptions): V2ListPromise<OutboundTransfer>;
+    /**
+     * Creates an OutboundTransfer.
+     * @throws Stripe.InsufficientFundsError
+     * @throws Stripe.FeatureNotEnabledError
+     */
+    create(params: V2.MoneyManagement.OutboundTransferCreateParams, options?: RequestOptions): Promise<Response<OutboundTransfer>>;
+    /**
+     * Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
+     */
+    retrieve(id: string, params?: V2.MoneyManagement.OutboundTransferRetrieveParams, options?: RequestOptions): Promise<Response<OutboundTransfer>>;
+    /**
+     * Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
+     * @throws Stripe.AlreadyCanceledError
+     * @throws Stripe.NotCancelableError
+     */
+    cancel(id: string, params?: V2.MoneyManagement.OutboundTransferCancelParams, options?: RequestOptions): Promise<Response<OutboundTransfer>>;
+}
+export interface OutboundTransfer {
+    /**
+     * Unique identifier for the OutboundTransfer.
+     */
+    id: string;
+    /**
+     * String representing the object's type. Objects of the same type share the same value of the object field.
+     */
+    object: 'v2.money_management.outbound_transfer';
+    /**
+     * The "presentment amount" for the OutboundTransfer.
+     */
+    amount: V2Amount;
+    /**
+     * Returns true if the OutboundTransfer can be canceled, and false otherwise.
+     */
+    cancelable: boolean;
+    /**
+     * Time at which the OutboundTransfer was created.
+     * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+     */
+    created: string;
+    /**
+     * Delivery options to be used to send the OutboundTransfer.
+     */
+    delivery_options?: V2.MoneyManagement.OutboundTransfer.DeliveryOptions;
+    /**
+     * An arbitrary string attached to the OutboundTransfer. Often useful for displaying to users.
+     */
+    description?: string;
+    /**
+     * The date when funds are expected to arrive in the payout method. This field is not set if the payout method is in a `failed`, `canceled`, or `returned` state.
+     * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+     */
+    expected_arrival_date?: string;
+    /**
+     * The FinancialAccount that funds were pulled from.
+     */
+    from: V2.MoneyManagement.OutboundTransfer.From;
+    /**
+     * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+     */
+    livemode: boolean;
+    /**
+     * 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.
+     */
+    metadata?: Metadata;
+    /**
+     * A link to the Stripe-hosted receipt for this OutboundTransfer. The receipt link remains active for 60 days from the OutboundTransfer creation date. After this period, the link will expire and the receipt url value will be null.
+     */
+    receipt_url?: string;
+    /**
+     * The recipient verification id for this OutboundTransfer. Only required for countries with regulatory mandates to verify recipient names before OutboundTransfer creation.
+     */
+    recipient_verification?: string;
+    /**
+     * The description that appears on the receiving end for an OutboundTransfer (for example, bank statement for external bank transfer). It will default to `STRIPE` if not set on the account settings.
+     */
+    statement_descriptor: string;
+    /**
+     * Closed Enum. Current status of the OutboundTransfer: `processing`, `failed`, `posted`, `returned`, `canceled`.
+     * An OutboundTransfer is `processing` if it has been created and is processing.
+     * The status changes to `posted` once the OutboundTransfer has been "confirmed" and funds have left the account, or to `failed` or `canceled`.
+     * If an OutboundTransfer fails to arrive at its payout method, its status will change to `returned`.
+     */
+    status: V2.MoneyManagement.OutboundTransfer.Status;
+    /**
+     * Status details for an OutboundTransfer in a `failed` or `returned` state.
+     */
+    status_details?: V2.MoneyManagement.OutboundTransfer.StatusDetails;
+    /**
+     * Hash containing timestamps of when the object transitioned to a particular status.
+     */
+    status_transitions?: V2.MoneyManagement.OutboundTransfer.StatusTransitions;
+    /**
+     * To which payout method the OutboundTransfer was sent.
+     */
+    to: V2.MoneyManagement.OutboundTransfer.To;
+    /**
+     * A unique identifier that can be used to track this OutboundTransfer with recipient bank. Banks might call this a "reference number" or something similar.
+     */
+    trace_id: V2.MoneyManagement.OutboundTransfer.TraceId;
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        namespace OutboundTransfer {
+            interface DeliveryOptions {
+                /**
+                 * Open Enum. Method for bank account.
+                 */
+                bank_account?: DeliveryOptions.BankAccount;
+            }
+            interface From {
+                /**
+                 * The monetary amount debited from the sender, only set on responses.
+                 */
+                debited: V2Amount;
+                /**
+                 * The FinancialAccount that funds were pulled from.
+                 */
+                financial_account: string;
+            }
+            type Status = 'canceled' | 'failed' | 'posted' | 'processing' | 'returned';
+            interface StatusDetails {
+                /**
+                 * The `failed` status reason.
+                 */
+                failed?: StatusDetails.Failed;
+                /**
+                 * The `returned` status reason.
+                 */
+                returned?: StatusDetails.Returned;
+            }
+            interface StatusTransitions {
+                /**
+                 * Timestamp describing when an OutboundTransfer changed status to `canceled`.
+                 * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+                 */
+                canceled_at?: string;
+                /**
+                 * Timestamp describing when an OutboundTransfer changed status to `failed`.
+                 * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+                 */
+                failed_at?: string;
+                /**
+                 * Timestamp describing when an OutboundTransfer changed status to `posted`.
+                 * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+                 */
+                posted_at?: string;
+                /**
+                 * Timestamp describing when an OutboundTransfer changed status to `returned`.
+                 * Represented as a RFC 3339 date & time UTC value in millisecond precision, for example: 2022-09-18T13:22:18.123Z.
+                 */
+                returned_at?: string;
+            }
+            interface To {
+                /**
+                 * The monetary amount being credited to the destination.
+                 */
+                credited: V2Amount;
+                /**
+                 * The payout method which the OutboundTransfer uses to send payout.
+                 */
+                payout_method: string;
+            }
+            interface TraceId {
+                /**
+                 * Possible values are `pending`, `supported`, and `unsupported`. Initially set to `pending`, it changes to
+                 * `supported` when the recipient bank provides a trace ID, or `unsupported` if the recipient bank doesn't support it.
+                 * Note that this status may not align with the OutboundPayment or OutboundTransfer status and can remain `pending`
+                 * even after the payment or transfer is posted.
+                 */
+                status: TraceId.Status;
+                /**
+                 * The trace ID value if `trace_id.status` is `supported`, otherwise empty.
+                 */
+                value?: string;
+            }
+            namespace DeliveryOptions {
+                type BankAccount = 'automatic' | 'local' | 'wire';
+            }
+            namespace StatusDetails {
+                interface Failed {
+                    /**
+                     * Open Enum. The `failed` status reason.
+                     */
+                    reason: Failed.Reason;
+                }
+                interface Returned {
+                    /**
+                     * Open Enum. The `returned` status reason.
+                     */
+                    reason: Returned.Reason;
+                }
+                namespace Failed {
+                    type Reason = 'payout_method_amount_limit_exceeded' | 'payout_method_declined' | 'payout_method_does_not_exist' | 'payout_method_expired' | 'payout_method_unsupported' | 'payout_method_usage_frequency_limit_exceeded' | 'unknown_failure';
+                }
+                namespace Returned {
+                    type Reason = 'payout_method_canceled_by_customer' | 'payout_method_closed' | 'payout_method_currency_unsupported' | 'payout_method_does_not_exist' | 'payout_method_holder_address_incorrect' | 'payout_method_holder_details_incorrect' | 'payout_method_holder_name_incorrect' | 'payout_method_invalid_account_number' | 'payout_method_restricted' | 'recalled' | 'unknown_failure';
+                }
+            }
+            namespace TraceId {
+                type Status = 'pending' | 'supported' | 'unsupported';
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface OutboundTransferCreateParams {
+            /**
+             * The "presentment amount" for the OutboundPayment.
+             */
+            amount: V2Amount;
+            /**
+             * The FinancialAccount to pull funds from.
+             */
+            from: OutboundTransferCreateParams.From;
+            /**
+             * To which payout method to send the OutboundTransfer.
+             */
+            to: OutboundTransferCreateParams.To;
+            /**
+             * Delivery options to be used to send the OutboundTransfer.
+             */
+            delivery_options?: OutboundTransferCreateParams.DeliveryOptions;
+            /**
+             * An arbitrary string attached to the OutboundTransfer. Often useful for displaying to users.
+             */
+            description?: 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.
+             */
+            metadata?: MetadataParam;
+            /**
+             * The recipient verification id for this OutboundTransfer. Only required for countries with regulatory mandates to verify recipient names before OutboundTransfer creation.
+             */
+            recipient_verification?: string;
+            /**
+             * The description that appears on the receiving end for an OutboundTransfer (for example, on a bank statement). Must be between 3 and 22 characters long for most destinations (500 for FinancialAccount destinations), and not contain profanity.
+             */
+            statement_descriptor?: string;
+        }
+        namespace OutboundTransferCreateParams {
+            interface From {
+                /**
+                 * Describes the FinancialAmount's currency drawn from.
+                 */
+                currency: string;
+                /**
+                 * The FinancialAccount that funds were pulled from.
+                 */
+                financial_account: string;
+            }
+            interface To {
+                /**
+                 * Describes the currency to send to the recipient.
+                 * If included, this currency must match a currency supported by the destination.
+                 * Can be omitted in the following cases:
+                 * - destination only supports one currency
+                 * - destination supports multiple currencies and one of the currencies matches the FA currency
+                 * - destination supports multiple currencies and one of the currencies matches the presentment currency
+                 * Note - when both FA currency and presentment currency are supported, we pick the FA currency to minimize FX.
+                 */
+                currency?: string;
+                /**
+                 * The payout method which the OutboundTransfer uses to send payout.
+                 */
+                payout_method: string;
+            }
+            interface DeliveryOptions {
+                /**
+                 * Open Enum. Method for bank account.
+                 */
+                bank_account?: DeliveryOptions.BankAccount;
+            }
+            namespace DeliveryOptions {
+                type BankAccount = 'automatic' | 'local' | 'wire';
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface OutboundTransferRetrieveParams {
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface OutboundTransferListParams {
+            /**
+             * Filter for objects created at the specified timestamp.
+             * Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+             */
+            created?: string;
+            /**
+             * Filter for objects created after the specified timestamp.
+             * Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+             */
+            created_gt?: string;
+            /**
+             * Filter for objects created on or after the specified timestamp.
+             * Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+             */
+            created_gte?: string;
+            /**
+             * Filter for objects created before the specified timestamp.
+             * Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+             */
+            created_lt?: string;
+            /**
+             * Filter for objects created on or before the specified timestamp.
+             * Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+             */
+            created_lte?: string;
+            /**
+             * The maximum number of results to return.
+             */
+            limit?: number;
+            /**
+             * Closed Enum. Only return OutboundTransfers with this status.
+             */
+            status?: Array<OutboundTransferListParams.Status>;
+        }
+        namespace OutboundTransferListParams {
+            type Status = 'canceled' | 'failed' | 'posted' | 'processing' | 'returned';
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface OutboundTransferCancelParams {
+        }
+    }
+}

package/cjs/resources/V2/MoneyManagement/OutboundTransfers.js

@@ -0,0 +1,39 @@
+"use strict";
+// File generated from our OpenAPI spec
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundTransferResource = void 0;
+const StripeResource_js_1 = require("../../../StripeResource.js");
+class OutboundTransferResource extends StripeResource_js_1.StripeResource {
+    /**
+     * Returns a list of OutboundTransfers that match the provided filters.
+     */
+    list(params, options) {
+        return this._makeRequest('GET', '/v2/money_management/outbound_transfers', params, options, {
+            methodType: 'list',
+        });
+    }
+    /**
+     * Creates an OutboundTransfer.
+     * @throws Stripe.InsufficientFundsError
+     * @throws Stripe.FeatureNotEnabledError
+     */
+    create(params, options) {
+        return this._makeRequest('POST', '/v2/money_management/outbound_transfers', params, options);
+    }
+    /**
+     * Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
+     */
+    retrieve(id, params, options) {
+        return this._makeRequest('GET', `/v2/money_management/outbound_transfers/${id}`, params, options);
+    }
+    /**
+     * Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
+     * @throws Stripe.AlreadyCanceledError
+     * @throws Stripe.NotCancelableError
+     */
+    cancel(id, params, options) {
+        return this._makeRequest('POST', `/v2/money_management/outbound_transfers/${id}/cancel`, params, options);
+    }
+}
+exports.OutboundTransferResource = OutboundTransferResource;
+//# sourceMappingURL=OutboundTransfers.js.map

package/cjs/resources/V2/MoneyManagement/OutboundTransfers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutboundTransfers.js","sourceRoot":"","sources":["../../../../src/resources/V2/MoneyManagement/OutboundTransfers.ts"],"names":[],"mappings":";AAAA,uCAAuC;;;AAEvC,kEAA0D;AAK1D,MAAa,wBAAyB,SAAQ,kCAAc;IAC1D;;OAEG;IACH,IAAI,CACF,MAAsD,EACtD,OAAwB;QAExB,OAAO,IAAI,CAAC,YAAY,CACtB,KAAK,EACL,yCAAyC,EACzC,MAAM,EACN,OAAO,EACP;YACE,UAAU,EAAE,MAAM;SACnB,CACK,CAAC;IACX,CAAC;IACD;;;;OAIG;IACH,MAAM,CACJ,MAAuD,EACvD,OAAwB;QAExB,OAAO,IAAI,CAAC,YAAY,CACtB,MAAM,EACN,yCAAyC,EACzC,MAAM,EACN,OAAO,CACD,CAAC;IACX,CAAC;IACD;;OAEG;IACH,QAAQ,CACN,EAAU,EACV,MAA0D,EAC1D,OAAwB;QAExB,OAAO,IAAI,CAAC,YAAY,CACtB,KAAK,EACL,2CAA2C,EAAE,EAAE,EAC/C,MAAM,EACN,OAAO,CACD,CAAC;IACX,CAAC;IACD;;;;OAIG;IACH,MAAM,CACJ,EAAU,EACV,MAAwD,EACxD,OAAwB;QAExB,OAAO,IAAI,CAAC,YAAY,CACtB,MAAM,EACN,2CAA2C,EAAE,SAAS,EACtD,MAAM,EACN,OAAO,CACD,CAAC;IACX,CAAC;CACF;AAlED,4DAkEC"}

package/cjs/resources/V2/MoneyManagement/PayoutMethods.d.ts

@@ -0,0 +1,270 @@
+import { StripeResource } from '../../../StripeResource.js';
+import { RequestOptions, V2ListPromise, Response } from '../../../lib.js';
+export declare class PayoutMethodResource extends StripeResource {
+    /**
+     * List objects that adhere to the PayoutMethod interface.
+     */
+    list(params?: V2.MoneyManagement.PayoutMethodListParams, options?: RequestOptions): V2ListPromise<PayoutMethod>;
+    /**
+     * Retrieve a PayoutMethod object.
+     * @throws Stripe.InvalidPayoutMethodError
+     */
+    retrieve(id: string, params?: V2.MoneyManagement.PayoutMethodRetrieveParams, options?: RequestOptions): Promise<Response<PayoutMethod>>;
+    /**
+     * Archive a PayoutMethod object. Archived objects cannot be used as payout methods
+     * and will not appear in the payout method list.
+     * @throws Stripe.ControlledByDashboardError
+     * @throws Stripe.CannotProceedError
+     * @throws Stripe.InvalidPayoutMethodError
+     * @throws Stripe.ControlledByAlternateResourceError
+     */
+    archive(id: string, params?: V2.MoneyManagement.PayoutMethodArchiveParams, options?: RequestOptions): Promise<Response<PayoutMethod>>;
+    /**
+     * Unarchive an PayoutMethod object.
+     * @throws Stripe.ControlledByDashboardError
+     * @throws Stripe.InvalidPayoutMethodError
+     * @throws Stripe.ControlledByAlternateResourceError
+     */
+    unarchive(id: string, params?: V2.MoneyManagement.PayoutMethodUnarchiveParams, options?: RequestOptions): Promise<Response<PayoutMethod>>;
+}
+export interface PayoutMethod {
+    /**
+     * ID of the PayoutMethod object.
+     */
+    id: string;
+    /**
+     * String representing the object's type. Objects of the same type share the same value of the object field.
+     */
+    object: 'v2.money_management.payout_method';
+    /**
+     * The alternative reference for this payout method, if it's a projected payout method.
+     */
+    alternative_reference?: V2.MoneyManagement.PayoutMethod.AlternativeReference;
+    /**
+     * A set of available payout speeds for this payout method.
+     */
+    available_payout_speeds: Array<V2.MoneyManagement.PayoutMethod.AvailablePayoutSpeed>;
+    /**
+     * The PayoutMethodBankAccount object details.
+     */
+    bank_account?: V2.MoneyManagement.PayoutMethod.BankAccount;
+    /**
+     * The PayoutMethodCard object details.
+     */
+    card?: V2.MoneyManagement.PayoutMethod.Card;
+    /**
+     * Created timestamp.
+     */
+    created: string;
+    /**
+     * The PayoutMethodCryptoWallet object details.
+     */
+    crypto_wallet?: V2.MoneyManagement.PayoutMethod.CryptoWallet;
+    /**
+     * ID of the underlying active OutboundSetupIntent object, if any.
+     */
+    latest_outbound_setup_intent?: 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;
+    /**
+     * Whether the Payout Method is currently unusable for money movement, despite potentially being correctly set up.
+     * Please reach out to Stripe Support for more information.
+     */
+    restricted: boolean;
+    /**
+     * Closed Enum. The type of payout method.
+     */
+    type: V2.MoneyManagement.PayoutMethod.Type;
+    /**
+     * Indicates whether the payout method has met the necessary requirements for outbound money movement.
+     */
+    usage_status: V2.MoneyManagement.PayoutMethod.UsageStatus;
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        namespace PayoutMethod {
+            interface AlternativeReference {
+                /**
+                 * The ID of the alternative resource being referenced.
+                 */
+                id: string;
+                /**
+                 * The type of the alternative reference (e.g., external_account for V1 external accounts).
+                 */
+                type: AlternativeReference.Type;
+            }
+            type AvailablePayoutSpeed = 'instant' | 'standard';
+            interface BankAccount {
+                /**
+                 * Whether this PayoutMethodBankAccount object was archived. PayoutMethodBankAccount objects can be archived through
+                 * the /archive API, and they will not be automatically archived by Stripe. Archived PayoutMethodBankAccount objects
+                 * cannot be used as payout methods and will not appear in the payout method list.
+                 */
+                archived: boolean;
+                /**
+                 * The type of bank account (checking or savings).
+                 */
+                bank_account_type: BankAccount.BankAccountType;
+                /**
+                 * The name of the bank this bank account is in. This field is populated automatically by Stripe.
+                 */
+                bank_name: string;
+                /**
+                 * The branch number of the bank account, if present.
+                 */
+                branch_number?: string;
+                /**
+                 * The country code of the bank account.
+                 */
+                country: string;
+                /**
+                 * List of enabled flows for this bank account (wire or local).
+                 */
+                enabled_delivery_options: Array<string>;
+                /**
+                 * The ID of the Financial Connections Account used to create the bank account.
+                 */
+                financial_connections_account?: string;
+                /**
+                 * The last 4 digits of the account number.
+                 */
+                last4: string;
+                /**
+                 * The routing number of the bank account, if present.
+                 */
+                routing_number?: string;
+                /**
+                 * The list of currencies supported by this bank account.
+                 */
+                supported_currencies: Array<string>;
+                /**
+                 * The swift code of the bank or financial institution.
+                 */
+                swift_code?: string;
+            }
+            interface Card {
+                /**
+                 * Whether the PayoutMethodCard object was archived. PayoutMethodCard objects can be archived through
+                 * the /archive API, and they will not be automatically archived by Stripe. Archived PayoutMethodCard objects
+                 * cannot be used as payout methods and will not appear in the payout method list.
+                 */
+                archived: boolean;
+                /**
+                 * The month the card expires.
+                 */
+                exp_month: string;
+                /**
+                 * The year the card expires.
+                 */
+                exp_year: string;
+                /**
+                 * Uniquely identifies this particular card number. You can use this attribute to check whether two
+                 * recipients who've signed up with you are using the same card number, for example.
+                 */
+                fingerprint: string;
+                /**
+                 * The last 4 digits of the card number.
+                 */
+                last4: string;
+                /**
+                 * The list of currencies supported by this bank account.
+                 */
+                supported_currencies: Array<string>;
+            }
+            interface CryptoWallet {
+                /**
+                 * Destination wallet address.
+                 */
+                address: string;
+                /**
+                 * Whether the crypto wallet was archived. Crypto wallets can be archived through the /archive API,
+                 * and they will not be automatically archived by Stripe. Archived crypto wallets cannot be used as
+                 * payout method and will not appear in the payout method list.
+                 */
+                archived: boolean;
+                /**
+                 * Optional field, required if network supports memos (only "stellar" currently).
+                 */
+                memo?: string;
+                /**
+                 * Which rail is being used to make an outbound money movement to this wallet.
+                 */
+                network: CryptoWallet.Network;
+            }
+            type Type = 'bank_account' | 'card' | 'crypto_wallet';
+            interface UsageStatus {
+                /**
+                 * Payments status - used when sending OutboundPayments (sending funds to recipients).
+                 */
+                payments: UsageStatus.Payments;
+                /**
+                 * Transfers status - used when making an OutboundTransfer (sending funds to yourself).
+                 */
+                transfers: UsageStatus.Transfers;
+            }
+            namespace AlternativeReference {
+                type Type = 'external_account' | 'payment_method';
+            }
+            namespace BankAccount {
+                type BankAccountType = 'checking' | 'futsu' | 'savings' | 'toza';
+            }
+            namespace CryptoWallet {
+                type Network = 'arbitrum' | 'avalanche_c_chain' | 'base' | 'ethereum' | 'optimism' | 'polygon' | 'solana' | 'stellar' | 'tempo';
+            }
+            namespace UsageStatus {
+                type Payments = 'eligible' | 'invalid' | 'requires_action';
+                type Transfers = 'eligible' | 'invalid' | 'requires_action';
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface PayoutMethodRetrieveParams {
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface PayoutMethodListParams {
+            /**
+             * The page size.
+             */
+            limit?: number;
+            /**
+             * Usage status filter.
+             */
+            usage_status?: PayoutMethodListParams.UsageStatus;
+        }
+        namespace PayoutMethodListParams {
+            interface UsageStatus {
+                /**
+                 * List of payments status to filter by.
+                 */
+                payments?: Array<UsageStatus.Payment>;
+                /**
+                 * List of transfers status to filter by.
+                 */
+                transfers?: Array<UsageStatus.Transfer>;
+            }
+            namespace UsageStatus {
+                type Payment = 'eligible' | 'invalid' | 'requires_action';
+                type Transfer = 'eligible' | 'invalid' | 'requires_action';
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface PayoutMethodArchiveParams {
+        }
+    }
+}
+export declare namespace V2 {
+    namespace MoneyManagement {
+        interface PayoutMethodUnarchiveParams {
+        }
+    }
+}