stripe 20.1.2 → 20.2.0-alpha.2

package/types/V2/Core/Events.d.ts

@@ -23,6 +23,11 @@ declare module 'stripe' {
 
           namespace Reason {
             interface Request {
+              /**
+               * The client details that made the request.
+               */
+              client?: Request.Client;
+
               /**
                * ID of the API request that caused the event.
                */
@@ -33,6 +38,62 @@ declare module 'stripe' {
                */
               idempotency_key: string;
             }
+
+            namespace Request {
+              interface Client {
+                /**
+                 * The type of the client.
+                 */
+                type: Client.Type;
+
+                /**
+                 * API key that triggered the event.
+                 */
+                api_key?: Client.ApiKey;
+
+                /**
+                 * Dashboard user that triggered the event.
+                 */
+                dashboard_user?: Client.DashboardUser;
+
+                /**
+                 * Stripe action that triggered the event.
+                 */
+                stripe_action?: Client.StripeAction;
+              }
+
+              namespace Client {
+                interface ApiKey {
+                  /**
+                   * The ID of the API key.
+                   */
+                  id: string;
+                }
+
+                interface DashboardUser {
+                  /**
+                   * The email of the dashboard user.
+                   */
+                  email: string;
+
+                  /**
+                   * The IP address of the user.
+                   */
+                  ip_address: string;
+
+                  /**
+                   * The machine identifier of the user.
+                   */
+                  machine_identifier: string;
+                }
+
+                type StripeAction = {
+                  [key: string]: unknown;
+                };
+
+                type Type = 'api_key' | 'dashboard_user' | 'stripe_action';
+              }
+            }
           }
         }
 

package/types/V2/Core/EventsResource.d.ts

@@ -6,7 +6,12 @@ declare module 'stripe' {
   namespace Stripe {
     namespace V2 {
       namespace Core {
-        interface EventRetrieveParams {}
+        interface EventRetrieveParams {
+          /**
+           * Additional fields to include in the response.
+           */
+          include?: Array<'reason.request.client'>;
+        }
       }
 
       namespace Core {
@@ -16,6 +21,11 @@ declare module 'stripe' {
            */
           created?: Stripe.RangeQueryParam;
 
+          /**
+           * Additional fields to include in the response.
+           */
+          include?: Array<'reason.request.client'>;
+
           /**
            * The page size.
            */

package/types/V2/Core/Vault/GbBankAccounts.d.ts

@@ -0,0 +1,181 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Core {
+        namespace Vault {
+          /**
+           * Use the GBBankAccounts API to create and manage GB bank account objects
+           */
+          interface GbBankAccount {
+            /**
+             * The ID of the GBBankAccount object.
+             */
+            id: string;
+
+            /**
+             * String representing the object's type. Objects of the same type share the same value of the object field.
+             */
+            object: 'v2.core.vault.gb_bank_account';
+
+            /**
+             * The alternative reference for this payout method, if it's a projected payout method.
+             */
+            alternative_reference?: GbBankAccount.AlternativeReference;
+
+            /**
+             * Whether this bank account object was archived. Bank account objects can be archived through
+             * the /archive API, and they will not be automatically archived by Stripe. Archived bank account objects
+             * cannot be used as outbound destinations and will not appear in the outbound destination list.
+             */
+            archived: boolean;
+
+            /**
+             * Closed Enum. The type of the bank account (checking or savings).
+             */
+            bank_account_type: GbBankAccount.BankAccountType;
+
+            /**
+             * The name of the bank.
+             */
+            bank_name: string;
+
+            /**
+             * Information around the status of Confirmation of Payee matching done on this bank account.
+             * Confirmation of Payee is a name matching service that must be done before making OutboundPayments in the UK.
+             */
+            confirmation_of_payee: GbBankAccount.ConfirmationOfPayee;
+
+            /**
+             * Creation time.
+             */
+            created: string;
+
+            /**
+             * The last 4 digits of the account number or IBAN.
+             */
+            last4: 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 Sort Code of the bank account.
+             */
+            sort_code: string;
+          }
+
+          namespace GbBankAccount {
+            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;
+            }
+
+            namespace AlternativeReference {
+              type Type = 'external_account' | 'payment_method';
+            }
+
+            type BankAccountType = 'checking' | 'savings';
+
+            interface ConfirmationOfPayee {
+              /**
+               * The result of the Confirmation of Payee check, once the check has been initiated. Closed enum.
+               */
+              result: ConfirmationOfPayee.Result;
+
+              /**
+               * The current state of Confirmation of Payee on this bank account. Closed enum.
+               */
+              status: ConfirmationOfPayee.Status;
+            }
+
+            namespace ConfirmationOfPayee {
+              interface Result {
+                /**
+                 * When the CoP result was created.
+                 */
+                created: string;
+
+                /**
+                 * Whether or not the information of the bank account matches what you have provided. Closed enum.
+                 */
+                match_result: Result.MatchResult;
+
+                /**
+                 * The fields that CoP service matched against. Only has value if MATCH or PARTIAL_MATCH, empty otherwise.
+                 */
+                matched: Result.Matched;
+
+                /**
+                 * Human-readable message describing the match result.
+                 */
+                message: string;
+
+                /**
+                 * The fields that are matched against what the network has on file.
+                 */
+                provided: Result.Provided;
+              }
+
+              namespace Result {
+                interface Matched {
+                  /**
+                   * The business type given by the bank for this account, in case of a MATCH or PARTIAL_MATCH.
+                   * Closed enum.
+                   */
+                  business_type?: Matched.BusinessType;
+
+                  /**
+                   * The name given by the bank for this account, in case of a MATCH or PARTIAL_MATCH.
+                   */
+                  name?: string;
+                }
+
+                namespace Matched {
+                  type BusinessType = 'business' | 'personal';
+                }
+
+                type MatchResult =
+                  | 'match'
+                  | 'mismatch'
+                  | 'partial_match'
+                  | 'unavailable';
+
+                interface Provided {
+                  /**
+                   * The provided or Legal Entity business type to match against the CoP service. Closed enum.
+                   */
+                  business_type: Provided.BusinessType;
+
+                  /**
+                   * The provided or Legal Entity name to match against the CoP service.
+                   */
+                  name: string;
+                }
+
+                namespace Provided {
+                  type BusinessType = 'business' | 'personal';
+                }
+              }
+
+              type Status =
+                | 'awaiting_acknowledgement'
+                | 'confirmed'
+                | 'uninitiated';
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/types/V2/Core/Vault/GbBankAccountsResource.d.ts

@@ -0,0 +1,194 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountCreateParams {
+            /**
+             * The Account Number of the bank account.
+             */
+            account_number: string;
+
+            /**
+             * The Sort Code of the bank account.
+             */
+            sort_code: string;
+
+            /**
+             * Closed Enum. The type of the bank account (checking or savings).
+             */
+            bank_account_type?: GbBankAccountCreateParams.BankAccountType;
+
+            /**
+             * Whether or not to automatically perform Confirmation of Payee to verify the users information
+             * against what was provided by the bank. Doing so is required for all bank accounts not owned
+             * by you before making domestic UK OutboundPayments.
+             */
+            confirmation_of_payee?: GbBankAccountCreateParams.ConfirmationOfPayee;
+          }
+
+          namespace GbBankAccountCreateParams {
+            type BankAccountType = 'checking' | 'savings';
+
+            interface ConfirmationOfPayee {
+              /**
+               * The business type to be checked against. Legal entity information will be used if unspecified.
+               * Closed enum.
+               */
+              business_type?: ConfirmationOfPayee.BusinessType;
+
+              /**
+               * User specifies whether Confirmation of Payee is automatically initiated when creating the bank account.
+               */
+              initiate: boolean;
+
+              /**
+               * The name to be checked against. Legal entity information will be used if unspecified.
+               */
+              name?: string;
+            }
+
+            namespace ConfirmationOfPayee {
+              type BusinessType = 'business' | 'personal';
+            }
+          }
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountRetrieveParams {}
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountListParams {
+            /**
+             * Optionally set the maximum number of results per page. Defaults to 10.
+             */
+            limit?: number;
+          }
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountAcknowledgeConfirmationOfPayeeParams {}
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountArchiveParams {}
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          interface GbBankAccountInitiateConfirmationOfPayeeParams {
+            /**
+             * The business type to be checked against. Legal entity information will be used if unspecified.
+             */
+            business_type?: GbBankAccountInitiateConfirmationOfPayeeParams.BusinessType;
+
+            /**
+             * The name of the user to be checked against. Legal entity information will be used if unspecified.
+             */
+            name?: string;
+          }
+
+          namespace GbBankAccountInitiateConfirmationOfPayeeParams {
+            type BusinessType = 'business' | 'personal';
+          }
+        }
+      }
+
+      namespace Core {
+        namespace Vault {
+          class GbBankAccountsResource {
+            /**
+             * Create a GB bank account.
+             */
+            create(
+              params: GbBankAccountCreateParams,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+
+            /**
+             * Retrieve a GB bank account.
+             */
+            retrieve(
+              id: string,
+              params?: GbBankAccountRetrieveParams,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+            retrieve(
+              id: string,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+
+            /**
+             * List objects that can be used as destinations for outbound money movement via OutboundPayment.
+             */
+            list(
+              params?: GbBankAccountListParams,
+              options?: RequestOptions
+            ): ApiListPromise<Stripe.V2.Core.Vault.GbBankAccount>;
+            list(
+              options?: RequestOptions
+            ): ApiListPromise<Stripe.V2.Core.Vault.GbBankAccount>;
+
+            /**
+             * Confirm that you have received the result of the Confirmation of Payee request, and that you are okay with
+             * proceeding to pay out to this bank account despite the account not matching, partially matching, or the service
+             * being unavailable. Once you confirm this, you will be able to send OutboundPayments, but this may lead to
+             * funds being sent to the wrong account, which we might not be able to recover.
+             */
+            acknowledgeConfirmationOfPayee(
+              id: string,
+              params?: GbBankAccountAcknowledgeConfirmationOfPayeeParams,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+            acknowledgeConfirmationOfPayee(
+              id: string,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+
+            /**
+             * Archive a GBBankAccount object. Archived GBBankAccount objects cannot be used as outbound destinations
+             * and will not appear in the outbound destination list.
+             */
+            archive(
+              id: string,
+              params?: GbBankAccountArchiveParams,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+            archive(
+              id: string,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+
+            /**
+             * Initiate Confirmation of Payee (CoP) in order to verify that the owner of a UK bank account matches
+             * who you expect. This must be done on all UK bank accounts before sending domestic OutboundPayments. If
+             * the result is a partial match or a non match, explicit acknowledgement using AcknowledgeConfirmationOfPayee
+             * is required before sending funds.
+             */
+            initiateConfirmationOfPayee(
+              id: string,
+              params?: GbBankAccountInitiateConfirmationOfPayeeParams,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+            initiateConfirmationOfPayee(
+              id: string,
+              options?: RequestOptions
+            ): Promise<Stripe.Response<Stripe.V2.Core.Vault.GbBankAccount>>;
+          }
+        }
+      }
+    }
+  }
+}

package/types/V2/Core/Vault/UsBankAccounts.d.ts

@@ -0,0 +1,142 @@
+// File generated from our OpenAPI spec
+
+declare module 'stripe' {
+  namespace Stripe {
+    namespace V2 {
+      namespace Core {
+        namespace Vault {
+          /**
+           * Use the USBankAccounts API to create and manage US bank accounts objects that you can use to receive funds. Note that these are not interchangeable with v1 Tokens.
+           */
+          interface UsBankAccount {
+            /**
+             * The ID of the USBankAccount object.
+             */
+            id: string;
+
+            /**
+             * String representing the object's type. Objects of the same type share the same value of the object field.
+             */
+            object: 'v2.core.vault.us_bank_account';
+
+            /**
+             * The alternative reference for this payout method, if it's a projected payout method.
+             */
+            alternative_reference?: UsBankAccount.AlternativeReference;
+
+            /**
+             * Whether this USBankAccount object was archived.
+             */
+            archived: boolean;
+
+            /**
+             * Closed Enum. The type of bank account (checking or savings).
+             */
+            bank_account_type: UsBankAccount.BankAccountType;
+
+            /**
+             * The name of the bank this bank account belongs to. This field is populated automatically by Stripe based on the routing number.
+             */
+            bank_name: string;
+
+            /**
+             * Creation time of the object.
+             */
+            created: string;
+
+            /**
+             * The fedwire routing number of the bank account.
+             */
+            fedwire_routing_number?: 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;
+
+            /**
+             * 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 ACH routing number of the bank account.
+             */
+            routing_number?: string;
+
+            /**
+             * The bank account verification details.
+             */
+            verification: UsBankAccount.Verification;
+          }
+
+          namespace UsBankAccount {
+            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;
+            }
+
+            namespace AlternativeReference {
+              type Type = 'external_account' | 'payment_method';
+            }
+
+            type BankAccountType = 'checking' | 'savings';
+
+            interface Verification {
+              /**
+               * The microdeposit verification details if the status is awaiting verification.
+               */
+              microdeposit_verification_details?: Verification.MicrodepositVerificationDetails;
+
+              /**
+               * The bank account verification status.
+               */
+              status: Verification.Status;
+            }
+
+            namespace Verification {
+              interface MicrodepositVerificationDetails {
+                /**
+                 * Time when microdeposits will expire and have to be re-sent.
+                 */
+                expires: string;
+
+                /**
+                 * Microdeposit type can be amounts or descriptor_type.
+                 */
+                microdeposit_type: MicrodepositVerificationDetails.MicrodepositType;
+
+                /**
+                 * Time when microdeposits were sent.
+                 */
+                sent: string;
+              }
+
+              namespace MicrodepositVerificationDetails {
+                type MicrodepositType = 'amounts' | 'descriptor_code';
+              }
+
+              type Status =
+                | 'awaiting_verification'
+                | 'unverified'
+                | 'verification_failed'
+                | 'verified';
+            }
+          }
+        }
+      }
+    }
+  }
+}