From 0c948ce73364ff5d10e04253dc499118b3ba44ab Mon Sep 17 00:00:00 2001 From: "stripe-openapi[bot]" <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Thu, 13 Apr 2023 07:57:17 -0700 Subject: [PATCH 1/7] Update generated code (#1640) Update generated code for v296 Co-authored-by: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> --- OPENAPI_VERSION | 2 +- example/generated_examples_test.go | 90 ++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+), 1 deletion(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 0e2fd6c974..22402537f0 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v294 \ No newline at end of file +v296 \ No newline at end of file diff --git a/example/generated_examples_test.go b/example/generated_examples_test.go index d318716298..1231d0fb16 100644 --- a/example/generated_examples_test.go +++ b/example/generated_examples_test.go @@ -73,6 +73,7 @@ import ( testhelpers_treasury_receivedcredit "github.com/stripe/stripe-go/v74/testhelpers/treasury/receivedcredit" testhelpers_treasury_receiveddebit "github.com/stripe/stripe-go/v74/testhelpers/treasury/receiveddebit" _ "github.com/stripe/stripe-go/v74/testing" + token "github.com/stripe/stripe-go/v74/token" topup "github.com/stripe/stripe-go/v74/topup" transfer "github.com/stripe/stripe-go/v74/transfer" transferreversal "github.com/stripe/stripe-go/v74/transferreversal" @@ -533,6 +534,19 @@ func TestTestHelpersTreasuryReceivedDebitCreate(t *testing.T) { assert.NotNil(t, result) } +func TestTokenCreate(t *testing.T) { + params := &stripe.TokenParams{ + Card: &stripe.CardParams{ + Number: stripe.String("4242424242424242"), + ExpMonth: stripe.String("5"), + ExpYear: stripe.String("2023"), + CVC: stripe.String("314"), + }, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + func TestAccountLinkCreate(t *testing.T) { params := &stripe.AccountLinkParams{ Account: stripe.String("acct_xxxxxxxxxxxxx"), @@ -2428,6 +2442,69 @@ func TestTestHelpersTestClockAdvance2(t *testing.T) { assert.NotNil(t, result) } +func TestTokenCreate2(t *testing.T) { + params := &stripe.TokenParams{ + BankAccount: &stripe.BankAccountParams{ + Country: stripe.String("US"), + Currency: stripe.String(string(stripe.CurrencyUSD)), + AccountHolderName: stripe.String("Jenny Rosen"), + AccountHolderType: stripe.String("individual"), + RoutingNumber: stripe.String("110000000"), + AccountNumber: stripe.String("000123456789"), + }, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + +func TestTokenCreate3(t *testing.T) { + params := &stripe.TokenParams{ + PII: &stripe.TokenPIIParams{IDNumber: stripe.String("000000000")}, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + +func TestTokenCreate4(t *testing.T) { + params := &stripe.TokenParams{ + Account: &stripe.TokenAccountParams{ + Individual: &stripe.PersonParams{ + FirstName: stripe.String("Jane"), + LastName: stripe.String("Doe"), + }, + TOSShownAndAccepted: stripe.Bool(true), + }, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + +func TestTokenCreate5(t *testing.T) { + params := &stripe.TokenParams{ + Person: &stripe.PersonParams{ + FirstName: stripe.String("Jane"), + LastName: stripe.String("Doe"), + Relationship: &stripe.PersonRelationshipParams{Owner: stripe.Bool(true)}, + }, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + +func TestTokenCreate6(t *testing.T) { + params := &stripe.TokenParams{ + CVCUpdate: &stripe.TokenCVCUpdateParams{CVC: stripe.String("123")}, + } + result, _ := token.New(params) + assert.NotNil(t, result) +} + +func TestTokenRetrieve(t *testing.T) { + params := &stripe.TokenParams{} + result, _ := token.Get("tok_xxxx", params) + assert.NotNil(t, result) +} + func TestTopupList(t *testing.T) { params := &stripe.TopupListParams{} params.Limit = stripe.Int64(3) @@ -2828,3 +2905,16 @@ func TestTaxCalculationListLineItems(t *testing.T) { assert.NotNil(t, result) assert.Nil(t, result.Err()) } + +func TestPaymentIntentCreate3(t *testing.T) { + params := &stripe.PaymentIntentParams{ + Amount: stripe.Int64(200), + Currency: stripe.String(string(stripe.CurrencyUSD)), + PaymentMethodData: &stripe.PaymentIntentPaymentMethodDataParams{ + Type: stripe.String("p24"), + P24: &stripe.PaymentMethodP24Params{Bank: stripe.String("blik")}, + }, + } + result, _ := paymentintent.New(params) + assert.NotNil(t, result) +} From 89c5338d350ee5ca3c5c01c5786df573fb9c5124 Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Mon, 17 Apr 2023 18:48:27 +0000 Subject: [PATCH 2/7] Update generated code for v301 --- OPENAPI_VERSION | 2 +- identity_verificationsession.go | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 72ab4bc558..9010b7ef9e 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v299 \ No newline at end of file +v301 \ No newline at end of file diff --git a/identity_verificationsession.go b/identity_verificationsession.go index dfceae87da..111d541893 100644 --- a/identity_verificationsession.go +++ b/identity_verificationsession.go @@ -169,6 +169,8 @@ type IdentityVerificationSessionOptionsDocument struct { RequireMatchingSelfie bool `json:"require_matching_selfie"` } type IdentityVerificationSessionOptionsIDNumber struct{} + +// A set of options for the session's verification checks. type IdentityVerificationSessionOptions struct { Document *IdentityVerificationSessionOptionsDocument `json:"document"` IDNumber *IdentityVerificationSessionOptionsIDNumber `json:"id_number"` @@ -234,7 +236,8 @@ type IdentityVerificationSession struct { // Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Metadata map[string]string `json:"metadata"` // String representing the object's type. Objects of the same type share the same value. - Object string `json:"object"` + Object string `json:"object"` + // A set of options for the session's verification checks. Options *IdentityVerificationSessionOptions `json:"options"` // Redaction status of this VerificationSession. If the VerificationSession is not redacted, this field will be null. Redaction *IdentityVerificationSessionRedaction `json:"redaction"` From 371824d4f385a2d7c132d96b1ca42df1511f7583 Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Wed, 19 Apr 2023 09:31:49 +0000 Subject: [PATCH 3/7] Update generated code for v302 --- OPENAPI_VERSION | 2 +- tax_registration.go | 1581 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 1559 insertions(+), 24 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 9010b7ef9e..4e8d2efa6a 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v301 \ No newline at end of file +v302 \ No newline at end of file diff --git a/tax_registration.go b/tax_registration.go index 39044eb0bf..7b196859f8 100644 --- a/tax_registration.go +++ b/tax_registration.go @@ -6,6 +6,652 @@ package stripe +// Type of registration in `country`. +type TaxRegistrationCountryOptionsAeType string + +// List of values that TaxRegistrationCountryOptionsAeType can take +const ( + TaxRegistrationCountryOptionsAeTypeStandard TaxRegistrationCountryOptionsAeType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsAtStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsAtStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsAtStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsAtStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsAtStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsAtStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsAtType string + +// List of values that TaxRegistrationCountryOptionsAtType can take +const ( + TaxRegistrationCountryOptionsAtTypeIoss TaxRegistrationCountryOptionsAtType = "ioss" + TaxRegistrationCountryOptionsAtTypeOssNonUnion TaxRegistrationCountryOptionsAtType = "oss_non_union" + TaxRegistrationCountryOptionsAtTypeOssUnion TaxRegistrationCountryOptionsAtType = "oss_union" + TaxRegistrationCountryOptionsAtTypeStandard TaxRegistrationCountryOptionsAtType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsAuType string + +// List of values that TaxRegistrationCountryOptionsAuType can take +const ( + TaxRegistrationCountryOptionsAuTypeStandard TaxRegistrationCountryOptionsAuType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsBeStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsBeStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsBeStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsBeStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsBeStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsBeStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsBeType string + +// List of values that TaxRegistrationCountryOptionsBeType can take +const ( + TaxRegistrationCountryOptionsBeTypeIoss TaxRegistrationCountryOptionsBeType = "ioss" + TaxRegistrationCountryOptionsBeTypeOssNonUnion TaxRegistrationCountryOptionsBeType = "oss_non_union" + TaxRegistrationCountryOptionsBeTypeOssUnion TaxRegistrationCountryOptionsBeType = "oss_union" + TaxRegistrationCountryOptionsBeTypeStandard TaxRegistrationCountryOptionsBeType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsBgStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsBgStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsBgStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsBgStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsBgStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsBgStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsBgType string + +// List of values that TaxRegistrationCountryOptionsBgType can take +const ( + TaxRegistrationCountryOptionsBgTypeIoss TaxRegistrationCountryOptionsBgType = "ioss" + TaxRegistrationCountryOptionsBgTypeOssNonUnion TaxRegistrationCountryOptionsBgType = "oss_non_union" + TaxRegistrationCountryOptionsBgTypeOssUnion TaxRegistrationCountryOptionsBgType = "oss_union" + TaxRegistrationCountryOptionsBgTypeStandard TaxRegistrationCountryOptionsBgType = "standard" +) + +// Type of registration in Canada. +type TaxRegistrationCountryOptionsCaType string + +// List of values that TaxRegistrationCountryOptionsCaType can take +const ( + TaxRegistrationCountryOptionsCaTypeProvinceStandard TaxRegistrationCountryOptionsCaType = "province_standard" + TaxRegistrationCountryOptionsCaTypeSimplified TaxRegistrationCountryOptionsCaType = "simplified" + TaxRegistrationCountryOptionsCaTypeStandard TaxRegistrationCountryOptionsCaType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsChType string + +// List of values that TaxRegistrationCountryOptionsChType can take +const ( + TaxRegistrationCountryOptionsChTypeStandard TaxRegistrationCountryOptionsChType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsCyStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsCyStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsCyStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsCyStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsCyStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsCyStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsCyType string + +// List of values that TaxRegistrationCountryOptionsCyType can take +const ( + TaxRegistrationCountryOptionsCyTypeIoss TaxRegistrationCountryOptionsCyType = "ioss" + TaxRegistrationCountryOptionsCyTypeOssNonUnion TaxRegistrationCountryOptionsCyType = "oss_non_union" + TaxRegistrationCountryOptionsCyTypeOssUnion TaxRegistrationCountryOptionsCyType = "oss_union" + TaxRegistrationCountryOptionsCyTypeStandard TaxRegistrationCountryOptionsCyType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsCzStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsCzStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsCzStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsCzStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsCzStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsCzStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsCzType string + +// List of values that TaxRegistrationCountryOptionsCzType can take +const ( + TaxRegistrationCountryOptionsCzTypeIoss TaxRegistrationCountryOptionsCzType = "ioss" + TaxRegistrationCountryOptionsCzTypeOssNonUnion TaxRegistrationCountryOptionsCzType = "oss_non_union" + TaxRegistrationCountryOptionsCzTypeOssUnion TaxRegistrationCountryOptionsCzType = "oss_union" + TaxRegistrationCountryOptionsCzTypeStandard TaxRegistrationCountryOptionsCzType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsDeStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsDeStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsDeStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsDeStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsDeStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsDeStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsDeType string + +// List of values that TaxRegistrationCountryOptionsDeType can take +const ( + TaxRegistrationCountryOptionsDeTypeIoss TaxRegistrationCountryOptionsDeType = "ioss" + TaxRegistrationCountryOptionsDeTypeOssNonUnion TaxRegistrationCountryOptionsDeType = "oss_non_union" + TaxRegistrationCountryOptionsDeTypeOssUnion TaxRegistrationCountryOptionsDeType = "oss_union" + TaxRegistrationCountryOptionsDeTypeStandard TaxRegistrationCountryOptionsDeType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsDkStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsDkStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsDkStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsDkStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsDkStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsDkStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsDkType string + +// List of values that TaxRegistrationCountryOptionsDkType can take +const ( + TaxRegistrationCountryOptionsDkTypeIoss TaxRegistrationCountryOptionsDkType = "ioss" + TaxRegistrationCountryOptionsDkTypeOssNonUnion TaxRegistrationCountryOptionsDkType = "oss_non_union" + TaxRegistrationCountryOptionsDkTypeOssUnion TaxRegistrationCountryOptionsDkType = "oss_union" + TaxRegistrationCountryOptionsDkTypeStandard TaxRegistrationCountryOptionsDkType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsEeStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsEeStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsEeStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsEeStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsEeStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsEeStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsEeType string + +// List of values that TaxRegistrationCountryOptionsEeType can take +const ( + TaxRegistrationCountryOptionsEeTypeIoss TaxRegistrationCountryOptionsEeType = "ioss" + TaxRegistrationCountryOptionsEeTypeOssNonUnion TaxRegistrationCountryOptionsEeType = "oss_non_union" + TaxRegistrationCountryOptionsEeTypeOssUnion TaxRegistrationCountryOptionsEeType = "oss_union" + TaxRegistrationCountryOptionsEeTypeStandard TaxRegistrationCountryOptionsEeType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsEsStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsEsStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsEsStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsEsStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsEsStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsEsStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsEsType string + +// List of values that TaxRegistrationCountryOptionsEsType can take +const ( + TaxRegistrationCountryOptionsEsTypeIoss TaxRegistrationCountryOptionsEsType = "ioss" + TaxRegistrationCountryOptionsEsTypeOssNonUnion TaxRegistrationCountryOptionsEsType = "oss_non_union" + TaxRegistrationCountryOptionsEsTypeOssUnion TaxRegistrationCountryOptionsEsType = "oss_union" + TaxRegistrationCountryOptionsEsTypeStandard TaxRegistrationCountryOptionsEsType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsFiStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsFiStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsFiStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsFiStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsFiStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsFiStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsFiType string + +// List of values that TaxRegistrationCountryOptionsFiType can take +const ( + TaxRegistrationCountryOptionsFiTypeIoss TaxRegistrationCountryOptionsFiType = "ioss" + TaxRegistrationCountryOptionsFiTypeOssNonUnion TaxRegistrationCountryOptionsFiType = "oss_non_union" + TaxRegistrationCountryOptionsFiTypeOssUnion TaxRegistrationCountryOptionsFiType = "oss_union" + TaxRegistrationCountryOptionsFiTypeStandard TaxRegistrationCountryOptionsFiType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsFrStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsFrStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsFrStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsFrStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsFrStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsFrStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsFrType string + +// List of values that TaxRegistrationCountryOptionsFrType can take +const ( + TaxRegistrationCountryOptionsFrTypeIoss TaxRegistrationCountryOptionsFrType = "ioss" + TaxRegistrationCountryOptionsFrTypeOssNonUnion TaxRegistrationCountryOptionsFrType = "oss_non_union" + TaxRegistrationCountryOptionsFrTypeOssUnion TaxRegistrationCountryOptionsFrType = "oss_union" + TaxRegistrationCountryOptionsFrTypeStandard TaxRegistrationCountryOptionsFrType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsGBType string + +// List of values that TaxRegistrationCountryOptionsGBType can take +const ( + TaxRegistrationCountryOptionsGBTypeStandard TaxRegistrationCountryOptionsGBType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsGrStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsGrStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsGrStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsGrStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsGrStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsGrStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsGrType string + +// List of values that TaxRegistrationCountryOptionsGrType can take +const ( + TaxRegistrationCountryOptionsGrTypeIoss TaxRegistrationCountryOptionsGrType = "ioss" + TaxRegistrationCountryOptionsGrTypeOssNonUnion TaxRegistrationCountryOptionsGrType = "oss_non_union" + TaxRegistrationCountryOptionsGrTypeOssUnion TaxRegistrationCountryOptionsGrType = "oss_union" + TaxRegistrationCountryOptionsGrTypeStandard TaxRegistrationCountryOptionsGrType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsHkType string + +// List of values that TaxRegistrationCountryOptionsHkType can take +const ( + TaxRegistrationCountryOptionsHkTypeStandard TaxRegistrationCountryOptionsHkType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsHrStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsHrStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsHrStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsHrStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsHrStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsHrStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsHrType string + +// List of values that TaxRegistrationCountryOptionsHrType can take +const ( + TaxRegistrationCountryOptionsHrTypeIoss TaxRegistrationCountryOptionsHrType = "ioss" + TaxRegistrationCountryOptionsHrTypeOssNonUnion TaxRegistrationCountryOptionsHrType = "oss_non_union" + TaxRegistrationCountryOptionsHrTypeOssUnion TaxRegistrationCountryOptionsHrType = "oss_union" + TaxRegistrationCountryOptionsHrTypeStandard TaxRegistrationCountryOptionsHrType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsHuStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsHuStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsHuStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsHuStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsHuStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsHuStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsHuType string + +// List of values that TaxRegistrationCountryOptionsHuType can take +const ( + TaxRegistrationCountryOptionsHuTypeIoss TaxRegistrationCountryOptionsHuType = "ioss" + TaxRegistrationCountryOptionsHuTypeOssNonUnion TaxRegistrationCountryOptionsHuType = "oss_non_union" + TaxRegistrationCountryOptionsHuTypeOssUnion TaxRegistrationCountryOptionsHuType = "oss_union" + TaxRegistrationCountryOptionsHuTypeStandard TaxRegistrationCountryOptionsHuType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsIeStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsIeStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsIeStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsIeStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsIeStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsIeStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsIeType string + +// List of values that TaxRegistrationCountryOptionsIeType can take +const ( + TaxRegistrationCountryOptionsIeTypeIoss TaxRegistrationCountryOptionsIeType = "ioss" + TaxRegistrationCountryOptionsIeTypeOssNonUnion TaxRegistrationCountryOptionsIeType = "oss_non_union" + TaxRegistrationCountryOptionsIeTypeOssUnion TaxRegistrationCountryOptionsIeType = "oss_union" + TaxRegistrationCountryOptionsIeTypeStandard TaxRegistrationCountryOptionsIeType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsIsType string + +// List of values that TaxRegistrationCountryOptionsIsType can take +const ( + TaxRegistrationCountryOptionsIsTypeStandard TaxRegistrationCountryOptionsIsType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsItStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsItStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsItStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsItStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsItStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsItStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsItType string + +// List of values that TaxRegistrationCountryOptionsItType can take +const ( + TaxRegistrationCountryOptionsItTypeIoss TaxRegistrationCountryOptionsItType = "ioss" + TaxRegistrationCountryOptionsItTypeOssNonUnion TaxRegistrationCountryOptionsItType = "oss_non_union" + TaxRegistrationCountryOptionsItTypeOssUnion TaxRegistrationCountryOptionsItType = "oss_union" + TaxRegistrationCountryOptionsItTypeStandard TaxRegistrationCountryOptionsItType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsJPType string + +// List of values that TaxRegistrationCountryOptionsJPType can take +const ( + TaxRegistrationCountryOptionsJPTypeStandard TaxRegistrationCountryOptionsJPType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsLtStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsLtStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsLtStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsLtStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsLtStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsLtStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsLtType string + +// List of values that TaxRegistrationCountryOptionsLtType can take +const ( + TaxRegistrationCountryOptionsLtTypeIoss TaxRegistrationCountryOptionsLtType = "ioss" + TaxRegistrationCountryOptionsLtTypeOssNonUnion TaxRegistrationCountryOptionsLtType = "oss_non_union" + TaxRegistrationCountryOptionsLtTypeOssUnion TaxRegistrationCountryOptionsLtType = "oss_union" + TaxRegistrationCountryOptionsLtTypeStandard TaxRegistrationCountryOptionsLtType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsLuStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsLuStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsLuStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsLuStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsLuStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsLuStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsLuType string + +// List of values that TaxRegistrationCountryOptionsLuType can take +const ( + TaxRegistrationCountryOptionsLuTypeIoss TaxRegistrationCountryOptionsLuType = "ioss" + TaxRegistrationCountryOptionsLuTypeOssNonUnion TaxRegistrationCountryOptionsLuType = "oss_non_union" + TaxRegistrationCountryOptionsLuTypeOssUnion TaxRegistrationCountryOptionsLuType = "oss_union" + TaxRegistrationCountryOptionsLuTypeStandard TaxRegistrationCountryOptionsLuType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsLvStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsLvStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsLvStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsLvStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsLvStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsLvStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsLvType string + +// List of values that TaxRegistrationCountryOptionsLvType can take +const ( + TaxRegistrationCountryOptionsLvTypeIoss TaxRegistrationCountryOptionsLvType = "ioss" + TaxRegistrationCountryOptionsLvTypeOssNonUnion TaxRegistrationCountryOptionsLvType = "oss_non_union" + TaxRegistrationCountryOptionsLvTypeOssUnion TaxRegistrationCountryOptionsLvType = "oss_union" + TaxRegistrationCountryOptionsLvTypeStandard TaxRegistrationCountryOptionsLvType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsMtStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsMtStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsMtStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsMtStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsMtStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsMtStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsMtType string + +// List of values that TaxRegistrationCountryOptionsMtType can take +const ( + TaxRegistrationCountryOptionsMtTypeIoss TaxRegistrationCountryOptionsMtType = "ioss" + TaxRegistrationCountryOptionsMtTypeOssNonUnion TaxRegistrationCountryOptionsMtType = "oss_non_union" + TaxRegistrationCountryOptionsMtTypeOssUnion TaxRegistrationCountryOptionsMtType = "oss_union" + TaxRegistrationCountryOptionsMtTypeStandard TaxRegistrationCountryOptionsMtType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsNlStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsNlStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsNlStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsNlStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsNlStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsNlStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsNlType string + +// List of values that TaxRegistrationCountryOptionsNlType can take +const ( + TaxRegistrationCountryOptionsNlTypeIoss TaxRegistrationCountryOptionsNlType = "ioss" + TaxRegistrationCountryOptionsNlTypeOssNonUnion TaxRegistrationCountryOptionsNlType = "oss_non_union" + TaxRegistrationCountryOptionsNlTypeOssUnion TaxRegistrationCountryOptionsNlType = "oss_union" + TaxRegistrationCountryOptionsNlTypeStandard TaxRegistrationCountryOptionsNlType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsNoType string + +// List of values that TaxRegistrationCountryOptionsNoType can take +const ( + TaxRegistrationCountryOptionsNoTypeStandard TaxRegistrationCountryOptionsNoType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsNzType string + +// List of values that TaxRegistrationCountryOptionsNzType can take +const ( + TaxRegistrationCountryOptionsNzTypeStandard TaxRegistrationCountryOptionsNzType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsPlStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsPlStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsPlStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsPlStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsPlStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsPlStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsPlType string + +// List of values that TaxRegistrationCountryOptionsPlType can take +const ( + TaxRegistrationCountryOptionsPlTypeIoss TaxRegistrationCountryOptionsPlType = "ioss" + TaxRegistrationCountryOptionsPlTypeOssNonUnion TaxRegistrationCountryOptionsPlType = "oss_non_union" + TaxRegistrationCountryOptionsPlTypeOssUnion TaxRegistrationCountryOptionsPlType = "oss_union" + TaxRegistrationCountryOptionsPlTypeStandard TaxRegistrationCountryOptionsPlType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsPtStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsPtStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsPtStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsPtStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsPtStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsPtStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsPtType string + +// List of values that TaxRegistrationCountryOptionsPtType can take +const ( + TaxRegistrationCountryOptionsPtTypeIoss TaxRegistrationCountryOptionsPtType = "ioss" + TaxRegistrationCountryOptionsPtTypeOssNonUnion TaxRegistrationCountryOptionsPtType = "oss_non_union" + TaxRegistrationCountryOptionsPtTypeOssUnion TaxRegistrationCountryOptionsPtType = "oss_union" + TaxRegistrationCountryOptionsPtTypeStandard TaxRegistrationCountryOptionsPtType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsRoStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsRoStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsRoStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsRoStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsRoStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsRoStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsRoType string + +// List of values that TaxRegistrationCountryOptionsRoType can take +const ( + TaxRegistrationCountryOptionsRoTypeIoss TaxRegistrationCountryOptionsRoType = "ioss" + TaxRegistrationCountryOptionsRoTypeOssNonUnion TaxRegistrationCountryOptionsRoType = "oss_non_union" + TaxRegistrationCountryOptionsRoTypeOssUnion TaxRegistrationCountryOptionsRoType = "oss_union" + TaxRegistrationCountryOptionsRoTypeStandard TaxRegistrationCountryOptionsRoType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsSeStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsSeStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsSeStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsSeStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsSeStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsSeStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsSeType string + +// List of values that TaxRegistrationCountryOptionsSeType can take +const ( + TaxRegistrationCountryOptionsSeTypeIoss TaxRegistrationCountryOptionsSeType = "ioss" + TaxRegistrationCountryOptionsSeTypeOssNonUnion TaxRegistrationCountryOptionsSeType = "oss_non_union" + TaxRegistrationCountryOptionsSeTypeOssUnion TaxRegistrationCountryOptionsSeType = "oss_union" + TaxRegistrationCountryOptionsSeTypeStandard TaxRegistrationCountryOptionsSeType = "standard" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsSgType string + +// List of values that TaxRegistrationCountryOptionsSgType can take +const ( + TaxRegistrationCountryOptionsSgTypeStandard TaxRegistrationCountryOptionsSgType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsSiStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsSiStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsSiStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsSiStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsSiStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsSiStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsSiType string + +// List of values that TaxRegistrationCountryOptionsSiType can take +const ( + TaxRegistrationCountryOptionsSiTypeIoss TaxRegistrationCountryOptionsSiType = "ioss" + TaxRegistrationCountryOptionsSiTypeOssNonUnion TaxRegistrationCountryOptionsSiType = "oss_non_union" + TaxRegistrationCountryOptionsSiTypeOssUnion TaxRegistrationCountryOptionsSiType = "oss_union" + TaxRegistrationCountryOptionsSiTypeStandard TaxRegistrationCountryOptionsSiType = "standard" +) + +// Place of supply scheme used in an EU standard registration. +type TaxRegistrationCountryOptionsSkStandardPlaceOfSupplyScheme string + +// List of values that TaxRegistrationCountryOptionsSkStandardPlaceOfSupplyScheme can take +const ( + TaxRegistrationCountryOptionsSkStandardPlaceOfSupplySchemeSmallSeller TaxRegistrationCountryOptionsSkStandardPlaceOfSupplyScheme = "small_seller" + TaxRegistrationCountryOptionsSkStandardPlaceOfSupplySchemeStandard TaxRegistrationCountryOptionsSkStandardPlaceOfSupplyScheme = "standard" +) + +// Type of registration in an EU country. +type TaxRegistrationCountryOptionsSkType string + +// List of values that TaxRegistrationCountryOptionsSkType can take +const ( + TaxRegistrationCountryOptionsSkTypeIoss TaxRegistrationCountryOptionsSkType = "ioss" + TaxRegistrationCountryOptionsSkTypeOssNonUnion TaxRegistrationCountryOptionsSkType = "oss_non_union" + TaxRegistrationCountryOptionsSkTypeOssUnion TaxRegistrationCountryOptionsSkType = "oss_union" + TaxRegistrationCountryOptionsSkTypeStandard TaxRegistrationCountryOptionsSkType = "standard" +) + +// Type of registration in the US. +type TaxRegistrationCountryOptionsUSType string + +// List of values that TaxRegistrationCountryOptionsUSType can take +const ( + TaxRegistrationCountryOptionsUSTypeStateSalesTax TaxRegistrationCountryOptionsUSType = "state_sales_tax" +) + +// Type of registration in `country`. +type TaxRegistrationCountryOptionsZaType string + +// List of values that TaxRegistrationCountryOptionsZaType can take +const ( + TaxRegistrationCountryOptionsZaTypeStandard TaxRegistrationCountryOptionsZaType = "standard" +) + // The status of the registration. This field is present for convenience and can be deduced from `active_from` and `expires_at`. type TaxRegistrationStatus string @@ -13,20 +659,7 @@ type TaxRegistrationStatus string const ( TaxRegistrationStatusActive TaxRegistrationStatus = "active" TaxRegistrationStatusExpired TaxRegistrationStatus = "expired" - TaxRegistrationStatusScheduled TaxRegistrationStatus = "scheduled" -) - -// The type of the registration. See [our guide](https://stripe.com/docs/tax/registering) for more information about registration types. -type TaxRegistrationType string - -// List of values that TaxRegistrationType can take -const ( - TaxRegistrationTypeDomesticSmallSeller TaxRegistrationType = "domestic_small_seller" - TaxRegistrationTypeIoss TaxRegistrationType = "ioss" - TaxRegistrationTypeSimplified TaxRegistrationType = "simplified" - TaxRegistrationTypeStandard TaxRegistrationType = "standard" - TaxRegistrationTypeVATOssNonUnion TaxRegistrationType = "vat_oss_non_union" - TaxRegistrationTypeVATOssUnion TaxRegistrationType = "vat_oss_union" + TaxRegistrationStatusScheduled TaxRegistrationStatus = "scheduled" ) // Returns a list of Tax Registration objects. @@ -36,6 +669,564 @@ type TaxRegistrationListParams struct { Status *string `form:"status"` } +// Options for the registration in AE. +type TaxRegistrationCountryOptionsAeParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsAtStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in AT. +type TaxRegistrationCountryOptionsAtParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsAtStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in AU. +type TaxRegistrationCountryOptionsAuParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsBeStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in BE. +type TaxRegistrationCountryOptionsBeParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsBeStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsBgStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in BG. +type TaxRegistrationCountryOptionsBgParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsBgStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the provincial tax registration. +type TaxRegistrationCountryOptionsCaProvinceStandardParams struct { + // Two-letter CA province code ([ISO 3166-2]((https://en.wikipedia.org/wiki/ISO_3166-2))). + Province *string `form:"province"` +} + +// Options for the registration in CA. +type TaxRegistrationCountryOptionsCaParams struct { + // Options for the provincial tax registration. + ProvinceStandard *TaxRegistrationCountryOptionsCaProvinceStandardParams `form:"province_standard"` + // Type of registration to be created in Canada. + Type *string `form:"type"` +} + +// Options for the registration in CH. +type TaxRegistrationCountryOptionsChParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsCyStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in CY. +type TaxRegistrationCountryOptionsCyParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsCyStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsCzStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in CZ. +type TaxRegistrationCountryOptionsCzParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsCzStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsDeStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in DE. +type TaxRegistrationCountryOptionsDeParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsDeStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsDkStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in DK. +type TaxRegistrationCountryOptionsDkParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsDkStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsEeStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in EE. +type TaxRegistrationCountryOptionsEeParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsEeStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsEsStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in ES. +type TaxRegistrationCountryOptionsEsParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsEsStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsFiStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in FI. +type TaxRegistrationCountryOptionsFiParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsFiStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsFrStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in FR. +type TaxRegistrationCountryOptionsFrParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsFrStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in GB. +type TaxRegistrationCountryOptionsGBParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsGrStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in GR. +type TaxRegistrationCountryOptionsGrParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsGrStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in HK. +type TaxRegistrationCountryOptionsHkParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsHrStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in HR. +type TaxRegistrationCountryOptionsHrParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsHrStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsHuStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in HU. +type TaxRegistrationCountryOptionsHuParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsHuStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsIeStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in IE. +type TaxRegistrationCountryOptionsIeParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsIeStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in IS. +type TaxRegistrationCountryOptionsIsParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsItStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in IT. +type TaxRegistrationCountryOptionsItParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsItStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in JP. +type TaxRegistrationCountryOptionsJPParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsLtStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in LT. +type TaxRegistrationCountryOptionsLtParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsLtStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsLuStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in LU. +type TaxRegistrationCountryOptionsLuParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsLuStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsLvStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in LV. +type TaxRegistrationCountryOptionsLvParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsLvStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsMtStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in MT. +type TaxRegistrationCountryOptionsMtParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsMtStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsNlStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in NL. +type TaxRegistrationCountryOptionsNlParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsNlStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in NO. +type TaxRegistrationCountryOptionsNoParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the registration in NZ. +type TaxRegistrationCountryOptionsNzParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsPlStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in PL. +type TaxRegistrationCountryOptionsPlParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsPlStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsPtStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in PT. +type TaxRegistrationCountryOptionsPtParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsPtStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsRoStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in RO. +type TaxRegistrationCountryOptionsRoParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsRoStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsSeStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in SE. +type TaxRegistrationCountryOptionsSeParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsSeStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the registration in SG. +type TaxRegistrationCountryOptionsSgParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsSiStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in SI. +type TaxRegistrationCountryOptionsSiParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsSiStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the standard registration. +type TaxRegistrationCountryOptionsSkStandardParams struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme *string `form:"place_of_supply_scheme"` +} + +// Options for the registration in SK. +type TaxRegistrationCountryOptionsSkParams struct { + // Options for the standard registration. + Standard *TaxRegistrationCountryOptionsSkStandardParams `form:"standard"` + // Type of registration to be created in an EU country. + Type *string `form:"type"` +} + +// Options for the local lease tax registration. +type TaxRegistrationCountryOptionsUSLocalLeaseTaxParams struct { + // A FIPS/GNIS code representing the local jurisdiction. + Jurisdiction *string `form:"jurisdiction"` +} + +// Options for the registration in US. +type TaxRegistrationCountryOptionsUSParams struct { + // Options for the local lease tax registration. + LocalLeaseTax *TaxRegistrationCountryOptionsUSLocalLeaseTaxParams `form:"local_lease_tax"` + // Two-letter US state code ([ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)). + State *string `form:"state"` + // Type of registration to be created in the US. + Type *string `form:"type"` +} + +// Options for the registration in ZA. +type TaxRegistrationCountryOptionsZaParams struct { + // Type of registration to be created in `country`. + Type *string `form:"type"` +} + +// Specific options for a registration in the specified `country`. +type TaxRegistrationCountryOptionsParams struct { + // Options for the registration in AE. + Ae *TaxRegistrationCountryOptionsAeParams `form:"ae"` + // Options for the registration in AT. + At *TaxRegistrationCountryOptionsAtParams `form:"at"` + // Options for the registration in AU. + Au *TaxRegistrationCountryOptionsAuParams `form:"au"` + // Options for the registration in BE. + Be *TaxRegistrationCountryOptionsBeParams `form:"be"` + // Options for the registration in BG. + Bg *TaxRegistrationCountryOptionsBgParams `form:"bg"` + // Options for the registration in CA. + Ca *TaxRegistrationCountryOptionsCaParams `form:"ca"` + // Options for the registration in CH. + Ch *TaxRegistrationCountryOptionsChParams `form:"ch"` + // Options for the registration in CY. + Cy *TaxRegistrationCountryOptionsCyParams `form:"cy"` + // Options for the registration in CZ. + Cz *TaxRegistrationCountryOptionsCzParams `form:"cz"` + // Options for the registration in DE. + De *TaxRegistrationCountryOptionsDeParams `form:"de"` + // Options for the registration in DK. + Dk *TaxRegistrationCountryOptionsDkParams `form:"dk"` + // Options for the registration in EE. + Ee *TaxRegistrationCountryOptionsEeParams `form:"ee"` + // Options for the registration in ES. + Es *TaxRegistrationCountryOptionsEsParams `form:"es"` + // Options for the registration in FI. + Fi *TaxRegistrationCountryOptionsFiParams `form:"fi"` + // Options for the registration in FR. + Fr *TaxRegistrationCountryOptionsFrParams `form:"fr"` + // Options for the registration in GB. + GB *TaxRegistrationCountryOptionsGBParams `form:"gb"` + // Options for the registration in GR. + Gr *TaxRegistrationCountryOptionsGrParams `form:"gr"` + // Options for the registration in HK. + Hk *TaxRegistrationCountryOptionsHkParams `form:"hk"` + // Options for the registration in HR. + Hr *TaxRegistrationCountryOptionsHrParams `form:"hr"` + // Options for the registration in HU. + Hu *TaxRegistrationCountryOptionsHuParams `form:"hu"` + // Options for the registration in IE. + Ie *TaxRegistrationCountryOptionsIeParams `form:"ie"` + // Options for the registration in IS. + Is *TaxRegistrationCountryOptionsIsParams `form:"is"` + // Options for the registration in IT. + It *TaxRegistrationCountryOptionsItParams `form:"it"` + // Options for the registration in JP. + JP *TaxRegistrationCountryOptionsJPParams `form:"jp"` + // Options for the registration in LT. + Lt *TaxRegistrationCountryOptionsLtParams `form:"lt"` + // Options for the registration in LU. + Lu *TaxRegistrationCountryOptionsLuParams `form:"lu"` + // Options for the registration in LV. + Lv *TaxRegistrationCountryOptionsLvParams `form:"lv"` + // Options for the registration in MT. + Mt *TaxRegistrationCountryOptionsMtParams `form:"mt"` + // Options for the registration in NL. + Nl *TaxRegistrationCountryOptionsNlParams `form:"nl"` + // Options for the registration in NO. + No *TaxRegistrationCountryOptionsNoParams `form:"no"` + // Options for the registration in NZ. + Nz *TaxRegistrationCountryOptionsNzParams `form:"nz"` + // Options for the registration in PL. + Pl *TaxRegistrationCountryOptionsPlParams `form:"pl"` + // Options for the registration in PT. + Pt *TaxRegistrationCountryOptionsPtParams `form:"pt"` + // Options for the registration in RO. + Ro *TaxRegistrationCountryOptionsRoParams `form:"ro"` + // Options for the registration in SE. + Se *TaxRegistrationCountryOptionsSeParams `form:"se"` + // Options for the registration in SG. + Sg *TaxRegistrationCountryOptionsSgParams `form:"sg"` + // Options for the registration in SI. + Si *TaxRegistrationCountryOptionsSiParams `form:"si"` + // Options for the registration in SK. + Sk *TaxRegistrationCountryOptionsSkParams `form:"sk"` + // Options for the registration in US. + US *TaxRegistrationCountryOptionsUSParams `form:"us"` + // Options for the registration in ZA. + Za *TaxRegistrationCountryOptionsZaParams `form:"za"` +} + // Creates a new Tax Registration object. type TaxRegistrationParams struct { Params `form:"*"` @@ -43,12 +1234,359 @@ type TaxRegistrationParams struct { ActiveFrom *int64 `form:"active_from"` // Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)). Country *string `form:"country"` + // Specific options for a registration in the specified `country`. + CountryOptions *TaxRegistrationCountryOptionsParams `form:"country_options"` // If set, the registration stops being active at this time. If not set, the registration will be active indefinitely. Measured in seconds since the Unix epoch. ExpiresAt *int64 `form:"expires_at"` - // State, county, province, or region. - State *string `form:"state"` - // The type of the Tax Registration. See [our guide](https://stripe.com/docs/tax/registering) for more information about registration types. - Type *string `form:"type"` +} +type TaxRegistrationCountryOptionsAe struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsAeType `json:"type"` +} +type TaxRegistrationCountryOptionsAtStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsAtStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsAt struct { + Standard *TaxRegistrationCountryOptionsAtStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsAtType `json:"type"` +} +type TaxRegistrationCountryOptionsAu struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsAuType `json:"type"` +} +type TaxRegistrationCountryOptionsBeStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsBeStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsBe struct { + Standard *TaxRegistrationCountryOptionsBeStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsBeType `json:"type"` +} +type TaxRegistrationCountryOptionsBgStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsBgStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsBg struct { + Standard *TaxRegistrationCountryOptionsBgStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsBgType `json:"type"` +} +type TaxRegistrationCountryOptionsCaProvinceStandard struct { + // Two-letter CA province code ([ISO 3166-2]((https://en.wikipedia.org/wiki/ISO_3166-2))). + Province string `json:"province"` +} +type TaxRegistrationCountryOptionsCa struct { + ProvinceStandard *TaxRegistrationCountryOptionsCaProvinceStandard `json:"province_standard"` + // Type of registration in Canada. + Type TaxRegistrationCountryOptionsCaType `json:"type"` +} +type TaxRegistrationCountryOptionsCh struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsChType `json:"type"` +} +type TaxRegistrationCountryOptionsCyStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsCyStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsCy struct { + Standard *TaxRegistrationCountryOptionsCyStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsCyType `json:"type"` +} +type TaxRegistrationCountryOptionsCzStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsCzStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsCz struct { + Standard *TaxRegistrationCountryOptionsCzStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsCzType `json:"type"` +} +type TaxRegistrationCountryOptionsDeStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsDeStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsDe struct { + Standard *TaxRegistrationCountryOptionsDeStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsDeType `json:"type"` +} +type TaxRegistrationCountryOptionsDkStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsDkStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsDk struct { + Standard *TaxRegistrationCountryOptionsDkStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsDkType `json:"type"` +} +type TaxRegistrationCountryOptionsEeStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsEeStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsEe struct { + Standard *TaxRegistrationCountryOptionsEeStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsEeType `json:"type"` +} +type TaxRegistrationCountryOptionsEsStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsEsStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsEs struct { + Standard *TaxRegistrationCountryOptionsEsStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsEsType `json:"type"` +} +type TaxRegistrationCountryOptionsFiStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsFiStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsFi struct { + Standard *TaxRegistrationCountryOptionsFiStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsFiType `json:"type"` +} +type TaxRegistrationCountryOptionsFrStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsFrStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsFr struct { + Standard *TaxRegistrationCountryOptionsFrStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsFrType `json:"type"` +} +type TaxRegistrationCountryOptionsGB struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsGBType `json:"type"` +} +type TaxRegistrationCountryOptionsGrStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsGrStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsGr struct { + Standard *TaxRegistrationCountryOptionsGrStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsGrType `json:"type"` +} +type TaxRegistrationCountryOptionsHk struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsHkType `json:"type"` +} +type TaxRegistrationCountryOptionsHrStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsHrStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsHr struct { + Standard *TaxRegistrationCountryOptionsHrStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsHrType `json:"type"` +} +type TaxRegistrationCountryOptionsHuStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsHuStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsHu struct { + Standard *TaxRegistrationCountryOptionsHuStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsHuType `json:"type"` +} +type TaxRegistrationCountryOptionsIeStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsIeStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsIe struct { + Standard *TaxRegistrationCountryOptionsIeStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsIeType `json:"type"` +} +type TaxRegistrationCountryOptionsIs struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsIsType `json:"type"` +} +type TaxRegistrationCountryOptionsItStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsItStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsIt struct { + Standard *TaxRegistrationCountryOptionsItStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsItType `json:"type"` +} +type TaxRegistrationCountryOptionsJP struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsJPType `json:"type"` +} +type TaxRegistrationCountryOptionsLtStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsLtStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsLt struct { + Standard *TaxRegistrationCountryOptionsLtStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsLtType `json:"type"` +} +type TaxRegistrationCountryOptionsLuStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsLuStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsLu struct { + Standard *TaxRegistrationCountryOptionsLuStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsLuType `json:"type"` +} +type TaxRegistrationCountryOptionsLvStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsLvStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsLv struct { + Standard *TaxRegistrationCountryOptionsLvStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsLvType `json:"type"` +} +type TaxRegistrationCountryOptionsMtStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsMtStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsMt struct { + Standard *TaxRegistrationCountryOptionsMtStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsMtType `json:"type"` +} +type TaxRegistrationCountryOptionsNlStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsNlStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsNl struct { + Standard *TaxRegistrationCountryOptionsNlStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsNlType `json:"type"` +} +type TaxRegistrationCountryOptionsNo struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsNoType `json:"type"` +} +type TaxRegistrationCountryOptionsNz struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsNzType `json:"type"` +} +type TaxRegistrationCountryOptionsPlStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsPlStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsPl struct { + Standard *TaxRegistrationCountryOptionsPlStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsPlType `json:"type"` +} +type TaxRegistrationCountryOptionsPtStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsPtStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsPt struct { + Standard *TaxRegistrationCountryOptionsPtStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsPtType `json:"type"` +} +type TaxRegistrationCountryOptionsRoStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsRoStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsRo struct { + Standard *TaxRegistrationCountryOptionsRoStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsRoType `json:"type"` +} +type TaxRegistrationCountryOptionsSeStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsSeStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsSe struct { + Standard *TaxRegistrationCountryOptionsSeStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsSeType `json:"type"` +} +type TaxRegistrationCountryOptionsSg struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsSgType `json:"type"` +} +type TaxRegistrationCountryOptionsSiStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsSiStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsSi struct { + Standard *TaxRegistrationCountryOptionsSiStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsSiType `json:"type"` +} +type TaxRegistrationCountryOptionsSkStandard struct { + // Place of supply scheme used in an EU standard registration. + PlaceOfSupplyScheme TaxRegistrationCountryOptionsSkStandardPlaceOfSupplyScheme `json:"place_of_supply_scheme"` +} +type TaxRegistrationCountryOptionsSk struct { + Standard *TaxRegistrationCountryOptionsSkStandard `json:"standard"` + // Type of registration in an EU country. + Type TaxRegistrationCountryOptionsSkType `json:"type"` +} +type TaxRegistrationCountryOptionsUSLocalLeaseTax struct { + // A FIPS/GNIS code representing the local jurisdiction. + Jurisdiction string `json:"jurisdiction"` +} +type TaxRegistrationCountryOptionsUS struct { + LocalLeaseTax *TaxRegistrationCountryOptionsUSLocalLeaseTax `json:"local_lease_tax"` + // Two-letter US state code ([ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)). + State string `json:"state"` + // Type of registration in the US. + Type TaxRegistrationCountryOptionsUSType `json:"type"` +} +type TaxRegistrationCountryOptionsZa struct { + // Type of registration in `country`. + Type TaxRegistrationCountryOptionsZaType `json:"type"` +} +type TaxRegistrationCountryOptions struct { + Ae *TaxRegistrationCountryOptionsAe `json:"ae"` + At *TaxRegistrationCountryOptionsAt `json:"at"` + Au *TaxRegistrationCountryOptionsAu `json:"au"` + Be *TaxRegistrationCountryOptionsBe `json:"be"` + Bg *TaxRegistrationCountryOptionsBg `json:"bg"` + Ca *TaxRegistrationCountryOptionsCa `json:"ca"` + Ch *TaxRegistrationCountryOptionsCh `json:"ch"` + Cy *TaxRegistrationCountryOptionsCy `json:"cy"` + Cz *TaxRegistrationCountryOptionsCz `json:"cz"` + De *TaxRegistrationCountryOptionsDe `json:"de"` + Dk *TaxRegistrationCountryOptionsDk `json:"dk"` + Ee *TaxRegistrationCountryOptionsEe `json:"ee"` + Es *TaxRegistrationCountryOptionsEs `json:"es"` + Fi *TaxRegistrationCountryOptionsFi `json:"fi"` + Fr *TaxRegistrationCountryOptionsFr `json:"fr"` + GB *TaxRegistrationCountryOptionsGB `json:"gb"` + Gr *TaxRegistrationCountryOptionsGr `json:"gr"` + Hk *TaxRegistrationCountryOptionsHk `json:"hk"` + Hr *TaxRegistrationCountryOptionsHr `json:"hr"` + Hu *TaxRegistrationCountryOptionsHu `json:"hu"` + Ie *TaxRegistrationCountryOptionsIe `json:"ie"` + Is *TaxRegistrationCountryOptionsIs `json:"is"` + It *TaxRegistrationCountryOptionsIt `json:"it"` + JP *TaxRegistrationCountryOptionsJP `json:"jp"` + Lt *TaxRegistrationCountryOptionsLt `json:"lt"` + Lu *TaxRegistrationCountryOptionsLu `json:"lu"` + Lv *TaxRegistrationCountryOptionsLv `json:"lv"` + Mt *TaxRegistrationCountryOptionsMt `json:"mt"` + Nl *TaxRegistrationCountryOptionsNl `json:"nl"` + No *TaxRegistrationCountryOptionsNo `json:"no"` + Nz *TaxRegistrationCountryOptionsNz `json:"nz"` + Pl *TaxRegistrationCountryOptionsPl `json:"pl"` + Pt *TaxRegistrationCountryOptionsPt `json:"pt"` + Ro *TaxRegistrationCountryOptionsRo `json:"ro"` + Se *TaxRegistrationCountryOptionsSe `json:"se"` + Sg *TaxRegistrationCountryOptionsSg `json:"sg"` + Si *TaxRegistrationCountryOptionsSi `json:"si"` + Sk *TaxRegistrationCountryOptionsSk `json:"sk"` + US *TaxRegistrationCountryOptionsUS `json:"us"` + Za *TaxRegistrationCountryOptionsZa `json:"za"` } // A Tax `Registration` lets us know that your business is registered to collect tax on payments within a region, enabling you to [automatically collect tax](https://stripe.com/docs/tax). @@ -59,7 +1597,8 @@ type TaxRegistration struct { // Time at which the registration becomes active. Measured in seconds since the Unix epoch. ActiveFrom int64 `json:"active_from"` // Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)). - Country string `json:"country"` + Country string `json:"country"` + CountryOptions *TaxRegistrationCountryOptions `json:"country_options"` // Time at which the object was created. Measured in seconds since the Unix epoch. Created int64 `json:"created"` // If set, the registration stops being active at this time. If not set, the registration will be active indefinitely. Measured in seconds since the Unix epoch. @@ -70,12 +1609,8 @@ type TaxRegistration struct { Livemode bool `json:"livemode"` // String representing the object's type. Objects of the same type share the same value. Object string `json:"object"` - // State, county, province, or region. - State string `json:"state"` // The status of the registration. This field is present for convenience and can be deduced from `active_from` and `expires_at`. Status TaxRegistrationStatus `json:"status"` - // The type of the registration. See [our guide](https://stripe.com/docs/tax/registering) for more information about registration types. - Type TaxRegistrationType `json:"type"` } // TaxRegistrationList is a list of Registrations as retrieved from a list endpoint. From ff7d1b7b43f88d93fe2f213f760533f678cae6a0 Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Thu, 20 Apr 2023 13:40:06 +0000 Subject: [PATCH 4/7] Update generated code for v304 --- OPENAPI_VERSION | 2 +- paymentintent.go | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 4e8d2efa6a..87ea99f52f 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v302 \ No newline at end of file +v304 \ No newline at end of file diff --git a/paymentintent.go b/paymentintent.go index 4b6f10a88b..705651aad9 100644 --- a/paymentintent.go +++ b/paymentintent.go @@ -707,6 +707,18 @@ const ( PaymentIntentPaymentMethodOptionsWeChatPaySetupFutureUsageNone PaymentIntentPaymentMethodOptionsWeChatPaySetupFutureUsage = "none" ) +// Indicates that you intend to make future payments with this PaymentIntent's payment method. +// +// Providing this parameter will [attach the payment method](https://stripe.com/docs/payments/save-during-payment) to the PaymentIntent's Customer, if present, after the PaymentIntent is confirmed and any required actions from the user are complete. If no Customer was provided, the payment method can still be [attached](https://stripe.com/docs/api/payment_methods/attach) to a Customer after the transaction completes. +// +// When processing card payments, Stripe also uses `setup_future_usage` to dynamically optimize your payment flow and comply with regional legislation and network rules, such as [SCA](https://stripe.com/docs/strong-customer-authentication). +type PaymentIntentPaymentMethodOptionsZipSetupFutureUsage string + +// List of values that PaymentIntentPaymentMethodOptionsZipSetupFutureUsage can take +const ( + PaymentIntentPaymentMethodOptionsZipSetupFutureUsageNone PaymentIntentPaymentMethodOptionsZipSetupFutureUsage = "none" +) + // Type of the payment method for which payment is in `processing` state, one of `card`. type PaymentIntentProcessingType string @@ -1518,6 +1530,18 @@ type PaymentIntentPaymentMethodOptionsWeChatPayParams struct { SetupFutureUsage *string `form:"setup_future_usage"` } +// If this is a `zip` PaymentMethod, this sub-hash contains details about the Zip payment method options. +type PaymentIntentPaymentMethodOptionsZipParams struct { + // Indicates that you intend to make future payments with this PaymentIntent's payment method. + // + // Providing this parameter will [attach the payment method](https://stripe.com/docs/payments/save-during-payment) to the PaymentIntent's Customer, if present, after the PaymentIntent is confirmed and any required actions from the user are complete. If no Customer was provided, the payment method can still be [attached](https://stripe.com/docs/api/payment_methods/attach) to a Customer after the transaction completes. + // + // When processing card payments, Stripe also uses `setup_future_usage` to dynamically optimize your payment flow and comply with regional legislation and network rules, such as [SCA](https://stripe.com/docs/strong-customer-authentication). + // + // If `setup_future_usage` is already set and you are performing a request using a publishable key, you may only update the value from `on_session` to `off_session`. + SetupFutureUsage *string `form:"setup_future_usage"` +} + // Payment-method-specific configuration for this PaymentIntent. type PaymentIntentPaymentMethodOptionsParams struct { // If this is a `acss_debit` PaymentMethod, this sub-hash contains details about the ACSS Debit payment method options. @@ -1584,6 +1608,8 @@ type PaymentIntentPaymentMethodOptionsParams struct { USBankAccount *PaymentIntentPaymentMethodOptionsUSBankAccountParams `form:"us_bank_account"` // If this is a `wechat_pay` PaymentMethod, this sub-hash contains details about the WeChat Pay payment method options. WeChatPay *PaymentIntentPaymentMethodOptionsWeChatPayParams `form:"wechat_pay"` + // If this is a `zip` PaymentMethod, this sub-hash contains details about the Zip payment method options. + Zip *PaymentIntentPaymentMethodOptionsZipParams `form:"zip"` } // Options to configure Radar. See [Radar Session](https://stripe.com/docs/radar/radar-session) for more information. @@ -2565,6 +2591,14 @@ type PaymentIntentPaymentMethodOptionsWeChatPay struct { // When processing card payments, Stripe also uses `setup_future_usage` to dynamically optimize your payment flow and comply with regional legislation and network rules, such as [SCA](https://stripe.com/docs/strong-customer-authentication). SetupFutureUsage PaymentIntentPaymentMethodOptionsWeChatPaySetupFutureUsage `json:"setup_future_usage"` } +type PaymentIntentPaymentMethodOptionsZip struct { + // Indicates that you intend to make future payments with this PaymentIntent's payment method. + // + // Providing this parameter will [attach the payment method](https://stripe.com/docs/payments/save-during-payment) to the PaymentIntent's Customer, if present, after the PaymentIntent is confirmed and any required actions from the user are complete. If no Customer was provided, the payment method can still be [attached](https://stripe.com/docs/api/payment_methods/attach) to a Customer after the transaction completes. + // + // When processing card payments, Stripe also uses `setup_future_usage` to dynamically optimize your payment flow and comply with regional legislation and network rules, such as [SCA](https://stripe.com/docs/strong-customer-authentication). + SetupFutureUsage PaymentIntentPaymentMethodOptionsZipSetupFutureUsage `json:"setup_future_usage"` +} // Payment-method-specific configuration for this PaymentIntent. type PaymentIntentPaymentMethodOptions struct { @@ -2600,6 +2634,7 @@ type PaymentIntentPaymentMethodOptions struct { Sofort *PaymentIntentPaymentMethodOptionsSofort `json:"sofort"` USBankAccount *PaymentIntentPaymentMethodOptionsUSBankAccount `json:"us_bank_account"` WeChatPay *PaymentIntentPaymentMethodOptionsWeChatPay `json:"wechat_pay"` + Zip *PaymentIntentPaymentMethodOptionsZip `json:"zip"` } type PaymentIntentProcessingCardCustomerNotification struct { // Whether customer approval has been requested for this payment. For payments greater than INR 15000 or mandate amount, the customer must provide explicit approval of the payment with their bank. From 37efa80dd36db7250233cf712f72f2751deea85a Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Thu, 20 Apr 2023 14:52:32 +0000 Subject: [PATCH 5/7] Update generated code for v305 --- OPENAPI_VERSION | 2 +- tax_registration.go | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 87ea99f52f..b7f624b839 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v304 \ No newline at end of file +v305 \ No newline at end of file diff --git a/tax_registration.go b/tax_registration.go index 7b196859f8..c46209b5dd 100644 --- a/tax_registration.go +++ b/tax_registration.go @@ -1123,7 +1123,7 @@ type TaxRegistrationCountryOptionsSkParams struct { // Options for the local lease tax registration. type TaxRegistrationCountryOptionsUSLocalLeaseTaxParams struct { - // A FIPS/GNIS code representing the local jurisdiction. + // A [FIPS code](https://www.census.gov/library/reference/code-lists/ansi.html) representing the local jurisdiction. Jurisdiction *string `form:"jurisdiction"` } @@ -1532,7 +1532,7 @@ type TaxRegistrationCountryOptionsSk struct { Type TaxRegistrationCountryOptionsSkType `json:"type"` } type TaxRegistrationCountryOptionsUSLocalLeaseTax struct { - // A FIPS/GNIS code representing the local jurisdiction. + // A [FIPS code](https://www.census.gov/library/reference/code-lists/ansi.html) representing the local jurisdiction. Jurisdiction string `json:"jurisdiction"` } type TaxRegistrationCountryOptionsUS struct { @@ -1591,7 +1591,7 @@ type TaxRegistrationCountryOptions struct { // A Tax `Registration` lets us know that your business is registered to collect tax on payments within a region, enabling you to [automatically collect tax](https://stripe.com/docs/tax). // -// Stripe will not register on your behalf with the relevant authorities when you create a Tax `Registration` object. For more information on how to register to collect tax, see [our guide](https://stripe.com/docs/tax/registering). +// Stripe doesn't register on your behalf with the relevant authorities when you create a Tax `Registration` object. For more information on how to register to collect tax, see [our guide](https://stripe.com/docs/tax/registering). type TaxRegistration struct { APIResource // Time at which the registration becomes active. Measured in seconds since the Unix epoch. From e052a1da96d9561b8806b9244763fe4edf270ed9 Mon Sep 17 00:00:00 2001 From: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Thu, 20 Apr 2023 15:48:11 +0000 Subject: [PATCH 6/7] Update generated code for v306 --- OPENAPI_VERSION | 2 +- tax_registration.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index b7f624b839..23f2146789 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v305 \ No newline at end of file +v306 \ No newline at end of file diff --git a/tax_registration.go b/tax_registration.go index c46209b5dd..c9a4981397 100644 --- a/tax_registration.go +++ b/tax_registration.go @@ -725,7 +725,7 @@ type TaxRegistrationCountryOptionsBgParams struct { // Options for the provincial tax registration. type TaxRegistrationCountryOptionsCaProvinceStandardParams struct { - // Two-letter CA province code ([ISO 3166-2]((https://en.wikipedia.org/wiki/ISO_3166-2))). + // Two-letter CA province code ([ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)). Province *string `form:"province"` } @@ -1275,7 +1275,7 @@ type TaxRegistrationCountryOptionsBg struct { Type TaxRegistrationCountryOptionsBgType `json:"type"` } type TaxRegistrationCountryOptionsCaProvinceStandard struct { - // Two-letter CA province code ([ISO 3166-2]((https://en.wikipedia.org/wiki/ISO_3166-2))). + // Two-letter CA province code ([ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)). Province string `json:"province"` } type TaxRegistrationCountryOptionsCa struct { From fe7072c8511319ce9a118206c4a59c76cd5521ec Mon Sep 17 00:00:00 2001 From: "stripe-openapi[bot]" <105521251+stripe-openapi[bot]@users.noreply.github.com> Date: Thu, 20 Apr 2023 10:52:59 -0700 Subject: [PATCH 7/7] Update generated code (#1643) Update generated code for v301 Co-authored-by: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com> --- OPENAPI_VERSION | 2 +- identity_verificationsession.go | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 22402537f0..9010b7ef9e 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v296 \ No newline at end of file +v301 \ No newline at end of file diff --git a/identity_verificationsession.go b/identity_verificationsession.go index dfceae87da..111d541893 100644 --- a/identity_verificationsession.go +++ b/identity_verificationsession.go @@ -169,6 +169,8 @@ type IdentityVerificationSessionOptionsDocument struct { RequireMatchingSelfie bool `json:"require_matching_selfie"` } type IdentityVerificationSessionOptionsIDNumber struct{} + +// A set of options for the session's verification checks. type IdentityVerificationSessionOptions struct { Document *IdentityVerificationSessionOptionsDocument `json:"document"` IDNumber *IdentityVerificationSessionOptionsIDNumber `json:"id_number"` @@ -234,7 +236,8 @@ type IdentityVerificationSession struct { // Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Metadata map[string]string `json:"metadata"` // String representing the object's type. Objects of the same type share the same value. - Object string `json:"object"` + Object string `json:"object"` + // A set of options for the session's verification checks. Options *IdentityVerificationSessionOptions `json:"options"` // Redaction status of this VerificationSession. If the VerificationSession is not redacted, this field will be null. Redaction *IdentityVerificationSessionRedaction `json:"redaction"`