diff --git a/OPENAPI_VERSION b/OPENAPI_VERSION index 6e38278212..05e9a4e740 100644 --- a/OPENAPI_VERSION +++ b/OPENAPI_VERSION @@ -1 +1 @@ -v630 \ No newline at end of file +v633 \ No newline at end of file diff --git a/src/Stripe.net/Entities/Tax/Registrations/Registration.cs b/src/Stripe.net/Entities/Tax/Registrations/Registration.cs new file mode 100644 index 0000000000..d40e96199e --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/Registration.cs @@ -0,0 +1,81 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using System; + using Newtonsoft.Json; + using Stripe.Infrastructure; + + /// + /// 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. + /// + /// 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. + /// + /// Related guide: Using the + /// Registrations API. + /// + public class Registration : StripeEntity, IHasId, IHasObject + { + /// + /// Unique identifier for the object. + /// + [JsonProperty("id")] + public string Id { get; set; } + + /// + /// String representing the object's type. Objects of the same type share the same value. + /// + [JsonProperty("object")] + public string Object { get; set; } + + /// + /// Time at which the registration becomes active. Measured in seconds since the Unix epoch. + /// + [JsonProperty("active_from")] + [JsonConverter(typeof(UnixDateTimeConverter))] + public DateTime ActiveFrom { get; set; } = Stripe.Infrastructure.DateTimeUtils.UnixEpoch; + + /// + /// Two-letter country code (ISO + /// 3166-1 alpha-2). + /// + [JsonProperty("country")] + public string Country { get; set; } + + [JsonProperty("country_options")] + public RegistrationCountryOptions CountryOptions { get; set; } + + /// + /// Time at which the object was created. Measured in seconds since the Unix epoch. + /// + [JsonProperty("created")] + [JsonConverter(typeof(UnixDateTimeConverter))] + public DateTime Created { get; set; } = Stripe.Infrastructure.DateTimeUtils.UnixEpoch; + + /// + /// 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. + /// + [JsonProperty("expires_at")] + [JsonConverter(typeof(UnixDateTimeConverter))] + public DateTime? ExpiresAt { get; set; } + + /// + /// Has the value true if the object exists in live mode or the value false if + /// the object exists in test mode. + /// + [JsonProperty("livemode")] + public bool Livemode { get; set; } + + /// + /// The status of the registration. This field is present for convenience and can be deduced + /// from active_from and expires_at. + /// One of: active, expired, or scheduled. + /// + [JsonProperty("status")] + public string Status { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptions.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptions.cs new file mode 100644 index 0000000000..31e991efb3 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptions.cs @@ -0,0 +1,155 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptions : StripeEntity + { + [JsonProperty("ae")] + public RegistrationCountryOptionsAe Ae { get; set; } + + [JsonProperty("at")] + public RegistrationCountryOptionsAt At { get; set; } + + [JsonProperty("au")] + public RegistrationCountryOptionsAu Au { get; set; } + + [JsonProperty("be")] + public RegistrationCountryOptionsBe Be { get; set; } + + [JsonProperty("bg")] + public RegistrationCountryOptionsBg Bg { get; set; } + + [JsonProperty("ca")] + public RegistrationCountryOptionsCa Ca { get; set; } + + [JsonProperty("ch")] + public RegistrationCountryOptionsCh Ch { get; set; } + + [JsonProperty("cl")] + public RegistrationCountryOptionsCl Cl { get; set; } + + [JsonProperty("co")] + public RegistrationCountryOptionsCo Co { get; set; } + + [JsonProperty("cy")] + public RegistrationCountryOptionsCy Cy { get; set; } + + [JsonProperty("cz")] + public RegistrationCountryOptionsCz Cz { get; set; } + + [JsonProperty("de")] + public RegistrationCountryOptionsDe De { get; set; } + + [JsonProperty("dk")] + public RegistrationCountryOptionsDk Dk { get; set; } + + [JsonProperty("ee")] + public RegistrationCountryOptionsEe Ee { get; set; } + + [JsonProperty("es")] + public RegistrationCountryOptionsEs Es { get; set; } + + [JsonProperty("fi")] + public RegistrationCountryOptionsFi Fi { get; set; } + + [JsonProperty("fr")] + public RegistrationCountryOptionsFr Fr { get; set; } + + [JsonProperty("gb")] + public RegistrationCountryOptionsGb Gb { get; set; } + + [JsonProperty("gr")] + public RegistrationCountryOptionsGr Gr { get; set; } + + [JsonProperty("hr")] + public RegistrationCountryOptionsHr Hr { get; set; } + + [JsonProperty("hu")] + public RegistrationCountryOptionsHu Hu { get; set; } + + [JsonProperty("id")] + public RegistrationCountryOptionsId Id { get; set; } + + [JsonProperty("ie")] + public RegistrationCountryOptionsIe Ie { get; set; } + + [JsonProperty("is")] + public RegistrationCountryOptionsIs Is { get; set; } + + [JsonProperty("it")] + public RegistrationCountryOptionsIt It { get; set; } + + [JsonProperty("jp")] + public RegistrationCountryOptionsJp Jp { get; set; } + + [JsonProperty("kr")] + public RegistrationCountryOptionsKr Kr { get; set; } + + [JsonProperty("lt")] + public RegistrationCountryOptionsLt Lt { get; set; } + + [JsonProperty("lu")] + public RegistrationCountryOptionsLu Lu { get; set; } + + [JsonProperty("lv")] + public RegistrationCountryOptionsLv Lv { get; set; } + + [JsonProperty("mt")] + public RegistrationCountryOptionsMt Mt { get; set; } + + [JsonProperty("mx")] + public RegistrationCountryOptionsMx Mx { get; set; } + + [JsonProperty("my")] + public RegistrationCountryOptionsMy My { get; set; } + + [JsonProperty("nl")] + public RegistrationCountryOptionsNl Nl { get; set; } + + [JsonProperty("no")] + public RegistrationCountryOptionsNo No { get; set; } + + [JsonProperty("nz")] + public RegistrationCountryOptionsNz Nz { get; set; } + + [JsonProperty("pl")] + public RegistrationCountryOptionsPl Pl { get; set; } + + [JsonProperty("pt")] + public RegistrationCountryOptionsPt Pt { get; set; } + + [JsonProperty("ro")] + public RegistrationCountryOptionsRo Ro { get; set; } + + [JsonProperty("sa")] + public RegistrationCountryOptionsSa Sa { get; set; } + + [JsonProperty("se")] + public RegistrationCountryOptionsSe Se { get; set; } + + [JsonProperty("sg")] + public RegistrationCountryOptionsSg Sg { get; set; } + + [JsonProperty("si")] + public RegistrationCountryOptionsSi Si { get; set; } + + [JsonProperty("sk")] + public RegistrationCountryOptionsSk Sk { get; set; } + + [JsonProperty("th")] + public RegistrationCountryOptionsTh Th { get; set; } + + [JsonProperty("tr")] + public RegistrationCountryOptionsTr Tr { get; set; } + + [JsonProperty("us")] + public RegistrationCountryOptionsUs Us { get; set; } + + [JsonProperty("vn")] + public RegistrationCountryOptionsVn Vn { get; set; } + + [JsonProperty("za")] + public RegistrationCountryOptionsZa Za { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAe.cs new file mode 100644 index 0000000000..c4dc706a91 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAe.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAe : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAt.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAt.cs new file mode 100644 index 0000000000..1ef24eb274 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAt.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAt : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsAtStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAtStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAtStandard.cs new file mode 100644 index 0000000000..7860c39af5 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAtStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAtStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAu.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAu.cs new file mode 100644 index 0000000000..75cb0df4af --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsAu.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAu : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBe.cs new file mode 100644 index 0000000000..8d0e2a0f74 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBe.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBe : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsBeStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBeStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBeStandard.cs new file mode 100644 index 0000000000..88c8df80ac --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBeStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBeStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBg.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBg.cs new file mode 100644 index 0000000000..01ba4f2517 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBg.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBg : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsBgStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBgStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBgStandard.cs new file mode 100644 index 0000000000..5d215e98c4 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsBgStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBgStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCa.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCa.cs new file mode 100644 index 0000000000..51e8caaa89 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCa.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCa : StripeEntity + { + [JsonProperty("province_standard")] + public RegistrationCountryOptionsCaProvinceStandard ProvinceStandard { get; set; } + + /// + /// Type of registration in Canada. + /// One of: province_standard, simplified, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandard.cs new file mode 100644 index 0000000000..901ae7c211 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCaProvinceStandard : StripeEntity + { + /// + /// Two-letter CA province code (ISO + /// 3166-2). + /// + [JsonProperty("province")] + public string Province { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCh.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCh.cs new file mode 100644 index 0000000000..e9212dc8b1 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCh.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCh : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCl.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCl.cs new file mode 100644 index 0000000000..e0c50f3b66 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCl.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCl : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCo.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCo.cs new file mode 100644 index 0000000000..140dd1163b --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCo.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCo : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCy.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCy.cs new file mode 100644 index 0000000000..4044369c4c --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCy.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCy : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsCyStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCyStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCyStandard.cs new file mode 100644 index 0000000000..cc770fffb7 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCyStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCyStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCz.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCz.cs new file mode 100644 index 0000000000..56ec9cc154 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCz.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCz : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsCzStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCzStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCzStandard.cs new file mode 100644 index 0000000000..205ff25bbf --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsCzStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCzStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDe.cs new file mode 100644 index 0000000000..ecb08d0903 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDe.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDe : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsDeStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDeStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDeStandard.cs new file mode 100644 index 0000000000..166f269c97 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDeStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDeStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDk.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDk.cs new file mode 100644 index 0000000000..15868a1c42 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDk.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDk : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsDkStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDkStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDkStandard.cs new file mode 100644 index 0000000000..3601728221 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsDkStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDkStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEe.cs new file mode 100644 index 0000000000..610d781e48 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEe.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEe : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsEeStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEeStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEeStandard.cs new file mode 100644 index 0000000000..60313a61ca --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEeStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEeStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEs.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEs.cs new file mode 100644 index 0000000000..056539776d --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEs.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEs : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsEsStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEsStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEsStandard.cs new file mode 100644 index 0000000000..b1d3095365 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsEsStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEsStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFi.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFi.cs new file mode 100644 index 0000000000..6308b281d3 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFi.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFi : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsFiStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFiStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFiStandard.cs new file mode 100644 index 0000000000..f9325ccee9 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFiStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFiStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFr.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFr.cs new file mode 100644 index 0000000000..288f6b0511 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFr.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFr : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsFrStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFrStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFrStandard.cs new file mode 100644 index 0000000000..84a95f484c --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsFrStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFrStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGb.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGb.cs new file mode 100644 index 0000000000..5ad7d7a0ec --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGb.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGb : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGr.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGr.cs new file mode 100644 index 0000000000..1a048ec4a6 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGr.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGr : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsGrStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGrStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGrStandard.cs new file mode 100644 index 0000000000..5e73ea475d --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsGrStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGrStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHr.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHr.cs new file mode 100644 index 0000000000..e0538cf0c7 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHr.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHr : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsHrStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHrStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHrStandard.cs new file mode 100644 index 0000000000..5beac81655 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHrStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHrStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHu.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHu.cs new file mode 100644 index 0000000000..fa5872e54a --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHu.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHu : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsHuStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHuStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHuStandard.cs new file mode 100644 index 0000000000..2c8e0a16dd --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsHuStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHuStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsId.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsId.cs new file mode 100644 index 0000000000..3be13978ae --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsId.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsId : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIe.cs new file mode 100644 index 0000000000..22b02dd7dc --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIe.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIe : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsIeStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIeStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIeStandard.cs new file mode 100644 index 0000000000..a08d7ef5b2 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIeStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIeStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIs.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIs.cs new file mode 100644 index 0000000000..0455838bf4 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIs.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIs : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIt.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIt.cs new file mode 100644 index 0000000000..dc554219a3 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsIt.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIt : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsItStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsItStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsItStandard.cs new file mode 100644 index 0000000000..b8e0b94c27 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsItStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsItStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsJp.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsJp.cs new file mode 100644 index 0000000000..ddb7dd6608 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsJp.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsJp : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsKr.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsKr.cs new file mode 100644 index 0000000000..214c3011c2 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsKr.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsKr : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLt.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLt.cs new file mode 100644 index 0000000000..271c218f5e --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLt.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLt : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsLtStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLtStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLtStandard.cs new file mode 100644 index 0000000000..1ad365524a --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLtStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLtStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLu.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLu.cs new file mode 100644 index 0000000000..0660e5a5f8 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLu.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLu : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsLuStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLuStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLuStandard.cs new file mode 100644 index 0000000000..b290342b51 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLuStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLuStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLv.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLv.cs new file mode 100644 index 0000000000..5220f355bd --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLv.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLv : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsLvStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLvStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLvStandard.cs new file mode 100644 index 0000000000..68d1c56db4 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsLvStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLvStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMt.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMt.cs new file mode 100644 index 0000000000..f40eed2de6 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMt.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMt : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsMtStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMtStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMtStandard.cs new file mode 100644 index 0000000000..236b8b9636 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMtStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMtStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMx.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMx.cs new file mode 100644 index 0000000000..5782720e76 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMx.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMx : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMy.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMy.cs new file mode 100644 index 0000000000..b952e9c3aa --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsMy.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMy : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNl.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNl.cs new file mode 100644 index 0000000000..92889414ee --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNl.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNl : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsNlStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNlStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNlStandard.cs new file mode 100644 index 0000000000..ea7be8c97a --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNlStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNlStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNo.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNo.cs new file mode 100644 index 0000000000..4e8797e9c6 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNo.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNo : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNz.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNz.cs new file mode 100644 index 0000000000..139aa2bc33 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsNz.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNz : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPl.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPl.cs new file mode 100644 index 0000000000..2d7328d37e --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPl.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPl : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsPlStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPlStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPlStandard.cs new file mode 100644 index 0000000000..7966dc030c --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPlStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPlStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPt.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPt.cs new file mode 100644 index 0000000000..3d88535cc1 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPt.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPt : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsPtStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPtStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPtStandard.cs new file mode 100644 index 0000000000..3c500a6a28 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsPtStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPtStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRo.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRo.cs new file mode 100644 index 0000000000..d9a4e17ef4 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRo.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsRo : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsRoStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRoStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRoStandard.cs new file mode 100644 index 0000000000..7abd3b2cca --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsRoStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsRoStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSa.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSa.cs new file mode 100644 index 0000000000..50bd304d1d --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSa.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSa : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSe.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSe.cs new file mode 100644 index 0000000000..07a064b2be --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSe.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSe : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsSeStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSeStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSeStandard.cs new file mode 100644 index 0000000000..2ee863f94d --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSeStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSeStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSg.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSg.cs new file mode 100644 index 0000000000..5c8ae2b89c --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSg.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSg : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSi.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSi.cs new file mode 100644 index 0000000000..2b98a4b50f --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSi.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSi : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsSiStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSiStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSiStandard.cs new file mode 100644 index 0000000000..ee53dd699b --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSiStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSiStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSk.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSk.cs new file mode 100644 index 0000000000..55aeb38547 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSk.cs @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSk : StripeEntity + { + [JsonProperty("standard")] + public RegistrationCountryOptionsSkStandard Standard { get; set; } + + /// + /// Type of registration in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSkStandard.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSkStandard.cs new file mode 100644 index 0000000000..90cd31b217 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsSkStandard.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSkStandard : StripeEntity + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTh.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTh.cs new file mode 100644 index 0000000000..319f454054 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTh.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsTh : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTr.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTr.cs new file mode 100644 index 0000000000..00aacd01ad --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsTr.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsTr : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUs.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUs.cs new file mode 100644 index 0000000000..583a6010b4 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUs.cs @@ -0,0 +1,29 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUs : StripeEntity + { + [JsonProperty("local_amusement_tax")] + public RegistrationCountryOptionsUsLocalAmusementTax LocalAmusementTax { get; set; } + + [JsonProperty("local_lease_tax")] + public RegistrationCountryOptionsUsLocalLeaseTax LocalLeaseTax { get; set; } + + /// + /// Two-letter US state code (ISO + /// 3166-2). + /// + [JsonProperty("state")] + public string State { get; set; } + + /// + /// Type of registration in the US. + /// One of: local_amusement_tax, local_lease_tax, + /// state_communications_tax, or state_sales_tax. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTax.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTax.cs new file mode 100644 index 0000000000..e7ba560e9f --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTax.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUsLocalAmusementTax : StripeEntity + { + /// + /// A FIPS code + /// representing the local jurisdiction. + /// + [JsonProperty("jurisdiction")] + public string Jurisdiction { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTax.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTax.cs new file mode 100644 index 0000000000..bfad26dbb7 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTax.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUsLocalLeaseTax : StripeEntity + { + /// + /// A FIPS code + /// representing the local jurisdiction. + /// + [JsonProperty("jurisdiction")] + public string Jurisdiction { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsVn.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsVn.cs new file mode 100644 index 0000000000..c7e10236df --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsVn.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsVn : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsZa.cs b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsZa.cs new file mode 100644 index 0000000000..2a15d3fe32 --- /dev/null +++ b/src/Stripe.net/Entities/Tax/Registrations/RegistrationCountryOptionsZa.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsZa : StripeEntity + { + /// + /// Type of registration in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Infrastructure/Public/StripeTypeRegistry.cs b/src/Stripe.net/Infrastructure/Public/StripeTypeRegistry.cs index ff122553f1..5f5a713d88 100644 --- a/src/Stripe.net/Infrastructure/Public/StripeTypeRegistry.cs +++ b/src/Stripe.net/Infrastructure/Public/StripeTypeRegistry.cs @@ -133,6 +133,7 @@ public static class StripeTypeRegistry { "tax.calculation_line_item", typeof(Tax.CalculationLineItem) }, + { "tax.registration", typeof(Tax.Registration) }, { "tax.settings", typeof(Tax.Settings) }, { "tax.transaction", typeof(Tax.Transaction) }, { diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationActiveFrom.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationActiveFrom.cs new file mode 100644 index 0000000000..d6d0215a64 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationActiveFrom.cs @@ -0,0 +1,13 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + public class RegistrationActiveFrom : StringEnum + { + public static readonly RegistrationActiveFrom Now = new RegistrationActiveFrom("now"); + + private RegistrationActiveFrom(string value) + : base(value) + { + } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAeOptions.cs new file mode 100644 index 0000000000..6bef3e3d54 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAeOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAeOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtOptions.cs new file mode 100644 index 0000000000..8949c345ef --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAtOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsAtStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtStandardOptions.cs new file mode 100644 index 0000000000..99094534fd --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAtStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAtStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAuOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAuOptions.cs new file mode 100644 index 0000000000..bb39fa7f88 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsAuOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsAuOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeOptions.cs new file mode 100644 index 0000000000..00912698aa --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBeOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsBeStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeStandardOptions.cs new file mode 100644 index 0000000000..1c4eb69454 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBeStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBeStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgOptions.cs new file mode 100644 index 0000000000..69573056a4 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBgOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsBgStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgStandardOptions.cs new file mode 100644 index 0000000000..0c180dc21b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsBgStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsBgStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaOptions.cs new file mode 100644 index 0000000000..6c2418efa5 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCaOptions : INestedOptions + { + /// + /// Options for the provincial tax registration. + /// + [JsonProperty("province_standard")] + public RegistrationCountryOptionsCaProvinceStandardOptions ProvinceStandard { get; set; } + + /// + /// Type of registration to be created in Canada. + /// One of: province_standard, simplified, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandardOptions.cs new file mode 100644 index 0000000000..5abe94f2f3 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCaProvinceStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCaProvinceStandardOptions : INestedOptions + { + /// + /// Two-letter CA province code (ISO + /// 3166-2). + /// + [JsonProperty("province")] + public string Province { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsChOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsChOptions.cs new file mode 100644 index 0000000000..724b79330a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsChOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsChOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsClOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsClOptions.cs new file mode 100644 index 0000000000..17913c1764 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsClOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsClOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCoOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCoOptions.cs new file mode 100644 index 0000000000..26fce2141b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCoOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCoOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyOptions.cs new file mode 100644 index 0000000000..32d619cf0c --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCyOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsCyStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyStandardOptions.cs new file mode 100644 index 0000000000..03e8430e74 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCyStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCyStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzOptions.cs new file mode 100644 index 0000000000..c215f4c458 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCzOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsCzStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzStandardOptions.cs new file mode 100644 index 0000000000..436ac24613 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsCzStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsCzStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeOptions.cs new file mode 100644 index 0000000000..2cdcf5a961 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDeOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsDeStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeStandardOptions.cs new file mode 100644 index 0000000000..b1691df88b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDeStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDeStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkOptions.cs new file mode 100644 index 0000000000..dbd2802da2 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDkOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsDkStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkStandardOptions.cs new file mode 100644 index 0000000000..a0de9baaf7 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsDkStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsDkStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeOptions.cs new file mode 100644 index 0000000000..c3616f4fa5 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEeOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsEeStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeStandardOptions.cs new file mode 100644 index 0000000000..23e339897b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEeStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEeStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsOptions.cs new file mode 100644 index 0000000000..165cb29aab --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEsOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsEsStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsStandardOptions.cs new file mode 100644 index 0000000000..af7d903d11 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsEsStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsEsStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiOptions.cs new file mode 100644 index 0000000000..e21d2cf2b0 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFiOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsFiStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiStandardOptions.cs new file mode 100644 index 0000000000..7a8a98658d --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFiStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFiStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrOptions.cs new file mode 100644 index 0000000000..21610f5262 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFrOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsFrStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrStandardOptions.cs new file mode 100644 index 0000000000..436f6fe4d2 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsFrStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsFrStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGbOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGbOptions.cs new file mode 100644 index 0000000000..e8d0793031 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGbOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGbOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrOptions.cs new file mode 100644 index 0000000000..fd3a2d1b12 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGrOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsGrStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrStandardOptions.cs new file mode 100644 index 0000000000..6ea5ec58a5 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsGrStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsGrStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrOptions.cs new file mode 100644 index 0000000000..a52c4c6532 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHrOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsHrStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrStandardOptions.cs new file mode 100644 index 0000000000..4247e9d4e7 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHrStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHrStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuOptions.cs new file mode 100644 index 0000000000..490cbc9a26 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHuOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsHuStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuStandardOptions.cs new file mode 100644 index 0000000000..02c15e6cfb --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsHuStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsHuStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIdOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIdOptions.cs new file mode 100644 index 0000000000..8a6af9c28b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIdOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIdOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeOptions.cs new file mode 100644 index 0000000000..6b01251f2a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIeOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsIeStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeStandardOptions.cs new file mode 100644 index 0000000000..81028a8490 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIeStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIeStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIsOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIsOptions.cs new file mode 100644 index 0000000000..b72fd84522 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsIsOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsIsOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItOptions.cs new file mode 100644 index 0000000000..88dbca2a93 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsItOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsItStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItStandardOptions.cs new file mode 100644 index 0000000000..6a9d786484 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsItStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsItStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsJpOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsJpOptions.cs new file mode 100644 index 0000000000..8cbc2b585a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsJpOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsJpOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsKrOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsKrOptions.cs new file mode 100644 index 0000000000..d34b4cc78b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsKrOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsKrOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtOptions.cs new file mode 100644 index 0000000000..bc64b829e7 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLtOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsLtStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtStandardOptions.cs new file mode 100644 index 0000000000..6bb8295caa --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLtStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLtStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuOptions.cs new file mode 100644 index 0000000000..c74bed0ab5 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLuOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsLuStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuStandardOptions.cs new file mode 100644 index 0000000000..9e3a5adcc4 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLuStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLuStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvOptions.cs new file mode 100644 index 0000000000..d90e980db1 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLvOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsLvStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvStandardOptions.cs new file mode 100644 index 0000000000..2343c8b41e --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsLvStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsLvStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtOptions.cs new file mode 100644 index 0000000000..4325cb6682 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMtOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsMtStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtStandardOptions.cs new file mode 100644 index 0000000000..ef75db376b --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMtStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMtStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMxOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMxOptions.cs new file mode 100644 index 0000000000..50dbc59e9f --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMxOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMxOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMyOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMyOptions.cs new file mode 100644 index 0000000000..676007e0fa --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsMyOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsMyOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlOptions.cs new file mode 100644 index 0000000000..dbbc9b85a0 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNlOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsNlStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlStandardOptions.cs new file mode 100644 index 0000000000..99204bf1a8 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNlStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNlStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNoOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNoOptions.cs new file mode 100644 index 0000000000..a40ea6560a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNoOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNoOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNzOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNzOptions.cs new file mode 100644 index 0000000000..3effdce2fb --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsNzOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsNzOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsOptions.cs new file mode 100644 index 0000000000..2891396a54 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsOptions.cs @@ -0,0 +1,302 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsOptions : INestedOptions + { + /// + /// Options for the registration in AE. + /// + [JsonProperty("ae")] + public RegistrationCountryOptionsAeOptions Ae { get; set; } + + /// + /// Options for the registration in AT. + /// + [JsonProperty("at")] + public RegistrationCountryOptionsAtOptions At { get; set; } + + /// + /// Options for the registration in AU. + /// + [JsonProperty("au")] + public RegistrationCountryOptionsAuOptions Au { get; set; } + + /// + /// Options for the registration in BE. + /// + [JsonProperty("be")] + public RegistrationCountryOptionsBeOptions Be { get; set; } + + /// + /// Options for the registration in BG. + /// + [JsonProperty("bg")] + public RegistrationCountryOptionsBgOptions Bg { get; set; } + + /// + /// Options for the registration in CA. + /// + [JsonProperty("ca")] + public RegistrationCountryOptionsCaOptions Ca { get; set; } + + /// + /// Options for the registration in CH. + /// + [JsonProperty("ch")] + public RegistrationCountryOptionsChOptions Ch { get; set; } + + /// + /// Options for the registration in CL. + /// + [JsonProperty("cl")] + public RegistrationCountryOptionsClOptions Cl { get; set; } + + /// + /// Options for the registration in CO. + /// + [JsonProperty("co")] + public RegistrationCountryOptionsCoOptions Co { get; set; } + + /// + /// Options for the registration in CY. + /// + [JsonProperty("cy")] + public RegistrationCountryOptionsCyOptions Cy { get; set; } + + /// + /// Options for the registration in CZ. + /// + [JsonProperty("cz")] + public RegistrationCountryOptionsCzOptions Cz { get; set; } + + /// + /// Options for the registration in DE. + /// + [JsonProperty("de")] + public RegistrationCountryOptionsDeOptions De { get; set; } + + /// + /// Options for the registration in DK. + /// + [JsonProperty("dk")] + public RegistrationCountryOptionsDkOptions Dk { get; set; } + + /// + /// Options for the registration in EE. + /// + [JsonProperty("ee")] + public RegistrationCountryOptionsEeOptions Ee { get; set; } + + /// + /// Options for the registration in ES. + /// + [JsonProperty("es")] + public RegistrationCountryOptionsEsOptions Es { get; set; } + + /// + /// Options for the registration in FI. + /// + [JsonProperty("fi")] + public RegistrationCountryOptionsFiOptions Fi { get; set; } + + /// + /// Options for the registration in FR. + /// + [JsonProperty("fr")] + public RegistrationCountryOptionsFrOptions Fr { get; set; } + + /// + /// Options for the registration in GB. + /// + [JsonProperty("gb")] + public RegistrationCountryOptionsGbOptions Gb { get; set; } + + /// + /// Options for the registration in GR. + /// + [JsonProperty("gr")] + public RegistrationCountryOptionsGrOptions Gr { get; set; } + + /// + /// Options for the registration in HR. + /// + [JsonProperty("hr")] + public RegistrationCountryOptionsHrOptions Hr { get; set; } + + /// + /// Options for the registration in HU. + /// + [JsonProperty("hu")] + public RegistrationCountryOptionsHuOptions Hu { get; set; } + + /// + /// Options for the registration in ID. + /// + [JsonProperty("id")] + public RegistrationCountryOptionsIdOptions Id { get; set; } + + /// + /// Options for the registration in IE. + /// + [JsonProperty("ie")] + public RegistrationCountryOptionsIeOptions Ie { get; set; } + + /// + /// Options for the registration in IS. + /// + [JsonProperty("is")] + public RegistrationCountryOptionsIsOptions Is { get; set; } + + /// + /// Options for the registration in IT. + /// + [JsonProperty("it")] + public RegistrationCountryOptionsItOptions It { get; set; } + + /// + /// Options for the registration in JP. + /// + [JsonProperty("jp")] + public RegistrationCountryOptionsJpOptions Jp { get; set; } + + /// + /// Options for the registration in KR. + /// + [JsonProperty("kr")] + public RegistrationCountryOptionsKrOptions Kr { get; set; } + + /// + /// Options for the registration in LT. + /// + [JsonProperty("lt")] + public RegistrationCountryOptionsLtOptions Lt { get; set; } + + /// + /// Options for the registration in LU. + /// + [JsonProperty("lu")] + public RegistrationCountryOptionsLuOptions Lu { get; set; } + + /// + /// Options for the registration in LV. + /// + [JsonProperty("lv")] + public RegistrationCountryOptionsLvOptions Lv { get; set; } + + /// + /// Options for the registration in MT. + /// + [JsonProperty("mt")] + public RegistrationCountryOptionsMtOptions Mt { get; set; } + + /// + /// Options for the registration in MX. + /// + [JsonProperty("mx")] + public RegistrationCountryOptionsMxOptions Mx { get; set; } + + /// + /// Options for the registration in MY. + /// + [JsonProperty("my")] + public RegistrationCountryOptionsMyOptions My { get; set; } + + /// + /// Options for the registration in NL. + /// + [JsonProperty("nl")] + public RegistrationCountryOptionsNlOptions Nl { get; set; } + + /// + /// Options for the registration in NO. + /// + [JsonProperty("no")] + public RegistrationCountryOptionsNoOptions No { get; set; } + + /// + /// Options for the registration in NZ. + /// + [JsonProperty("nz")] + public RegistrationCountryOptionsNzOptions Nz { get; set; } + + /// + /// Options for the registration in PL. + /// + [JsonProperty("pl")] + public RegistrationCountryOptionsPlOptions Pl { get; set; } + + /// + /// Options for the registration in PT. + /// + [JsonProperty("pt")] + public RegistrationCountryOptionsPtOptions Pt { get; set; } + + /// + /// Options for the registration in RO. + /// + [JsonProperty("ro")] + public RegistrationCountryOptionsRoOptions Ro { get; set; } + + /// + /// Options for the registration in SA. + /// + [JsonProperty("sa")] + public RegistrationCountryOptionsSaOptions Sa { get; set; } + + /// + /// Options for the registration in SE. + /// + [JsonProperty("se")] + public RegistrationCountryOptionsSeOptions Se { get; set; } + + /// + /// Options for the registration in SG. + /// + [JsonProperty("sg")] + public RegistrationCountryOptionsSgOptions Sg { get; set; } + + /// + /// Options for the registration in SI. + /// + [JsonProperty("si")] + public RegistrationCountryOptionsSiOptions Si { get; set; } + + /// + /// Options for the registration in SK. + /// + [JsonProperty("sk")] + public RegistrationCountryOptionsSkOptions Sk { get; set; } + + /// + /// Options for the registration in TH. + /// + [JsonProperty("th")] + public RegistrationCountryOptionsThOptions Th { get; set; } + + /// + /// Options for the registration in TR. + /// + [JsonProperty("tr")] + public RegistrationCountryOptionsTrOptions Tr { get; set; } + + /// + /// Options for the registration in US. + /// + [JsonProperty("us")] + public RegistrationCountryOptionsUsOptions Us { get; set; } + + /// + /// Options for the registration in VN. + /// + [JsonProperty("vn")] + public RegistrationCountryOptionsVnOptions Vn { get; set; } + + /// + /// Options for the registration in ZA. + /// + [JsonProperty("za")] + public RegistrationCountryOptionsZaOptions Za { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlOptions.cs new file mode 100644 index 0000000000..6799ca9690 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPlOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsPlStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlStandardOptions.cs new file mode 100644 index 0000000000..2154656842 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPlStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPlStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtOptions.cs new file mode 100644 index 0000000000..7f8974f615 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPtOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsPtStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtStandardOptions.cs new file mode 100644 index 0000000000..986253a745 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsPtStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsPtStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoOptions.cs new file mode 100644 index 0000000000..b4dbd85829 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsRoOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsRoStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoStandardOptions.cs new file mode 100644 index 0000000000..8f67b2daf5 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsRoStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsRoStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSaOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSaOptions.cs new file mode 100644 index 0000000000..8d09c741b1 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSaOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSaOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeOptions.cs new file mode 100644 index 0000000000..7989f4b1ce --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSeOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsSeStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeStandardOptions.cs new file mode 100644 index 0000000000..22b44213bb --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSeStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSeStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSgOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSgOptions.cs new file mode 100644 index 0000000000..53fb172980 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSgOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSgOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiOptions.cs new file mode 100644 index 0000000000..4a2e057d68 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSiOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsSiStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiStandardOptions.cs new file mode 100644 index 0000000000..cb6682d469 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSiStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSiStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkOptions.cs new file mode 100644 index 0000000000..d2ec7d71f7 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkOptions.cs @@ -0,0 +1,21 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSkOptions : INestedOptions + { + /// + /// Options for the standard registration. + /// + [JsonProperty("standard")] + public RegistrationCountryOptionsSkStandardOptions Standard { get; set; } + + /// + /// Type of registration to be created in an EU country. + /// One of: ioss, oss_non_union, oss_union, or standard. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkStandardOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkStandardOptions.cs new file mode 100644 index 0000000000..bcb8c6c188 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsSkStandardOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsSkStandardOptions : INestedOptions + { + /// + /// Place of supply scheme used in an EU standard registration. + /// One of: small_seller, or standard. + /// + [JsonProperty("place_of_supply_scheme")] + public string PlaceOfSupplyScheme { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsThOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsThOptions.cs new file mode 100644 index 0000000000..c7e9745ca7 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsThOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsThOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsTrOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsTrOptions.cs new file mode 100644 index 0000000000..e54f563d13 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsTrOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsTrOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTaxOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTaxOptions.cs new file mode 100644 index 0000000000..2baf30e47e --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalAmusementTaxOptions.cs @@ -0,0 +1,17 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUsLocalAmusementTaxOptions : INestedOptions + { + /// + /// A FIPS code + /// representing the local jurisdiction. Supported FIPS codes are: 14000 (Chicago), + /// 06613 (Bloomington), 21696 (East Dundee), 24582 (Evanston), and + /// 68081 (Schiller Park). + /// + [JsonProperty("jurisdiction")] + public string Jurisdiction { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTaxOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTaxOptions.cs new file mode 100644 index 0000000000..5759e3bee4 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsLocalLeaseTaxOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUsLocalLeaseTaxOptions : INestedOptions + { + /// + /// A FIPS code + /// representing the local jurisdiction. Supported FIPS codes are: 14000 (Chicago). + /// + [JsonProperty("jurisdiction")] + public string Jurisdiction { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsOptions.cs new file mode 100644 index 0000000000..31d76d7fca --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsUsOptions.cs @@ -0,0 +1,35 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsUsOptions : INestedOptions + { + /// + /// Options for the local amusement tax registration. + /// + [JsonProperty("local_amusement_tax")] + public RegistrationCountryOptionsUsLocalAmusementTaxOptions LocalAmusementTax { get; set; } + + /// + /// Options for the local lease tax registration. + /// + [JsonProperty("local_lease_tax")] + public RegistrationCountryOptionsUsLocalLeaseTaxOptions LocalLeaseTax { get; set; } + + /// + /// Two-letter US state code (ISO + /// 3166-2). + /// + [JsonProperty("state")] + public string State { get; set; } + + /// + /// Type of registration to be created in the US. + /// One of: local_amusement_tax, local_lease_tax, + /// state_communications_tax, or state_sales_tax. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsVnOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsVnOptions.cs new file mode 100644 index 0000000000..2647b68b77 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsVnOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsVnOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsZaOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsZaOptions.cs new file mode 100644 index 0000000000..6a2913b801 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCountryOptionsZaOptions.cs @@ -0,0 +1,14 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationCountryOptionsZaOptions : INestedOptions + { + /// + /// Type of registration to be created in country. + /// + [JsonProperty("type")] + public string Type { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationCreateOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationCreateOptions.cs new file mode 100644 index 0000000000..14cf2cc67a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationCreateOptions.cs @@ -0,0 +1,41 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using System; + using Newtonsoft.Json; + using Stripe.Infrastructure; + + public class RegistrationCreateOptions : BaseOptions + { + /// + /// Time at which the Tax Registration becomes active. It can be either now to + /// indicate the current time, or a future timestamp measured in seconds since the Unix + /// epoch. + /// + [JsonProperty("active_from")] + [JsonConverter(typeof(AnyOfConverter))] + public AnyOf ActiveFrom { get; set; } + + /// + /// Two-letter country code (ISO + /// 3166-1 alpha-2). + /// + [JsonProperty("country")] + public string Country { get; set; } + + /// + /// Specific options for a registration in the specified country. + /// + [JsonProperty("country_options")] + public RegistrationCountryOptionsOptions CountryOptions { get; set; } + + /// + /// If set, the Tax Registration stops being active at this time. If not set, the Tax + /// Registration will be active indefinitely. Timestamp measured in seconds since the Unix + /// epoch. + /// + [JsonProperty("expires_at")] + [JsonConverter(typeof(UnixDateTimeConverter))] + public DateTime? ExpiresAt { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationExpiresAt.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationExpiresAt.cs new file mode 100644 index 0000000000..bcb0e3f224 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationExpiresAt.cs @@ -0,0 +1,13 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + public class RegistrationExpiresAt : StringEnum + { + public static readonly RegistrationExpiresAt Now = new RegistrationExpiresAt("now"); + + private RegistrationExpiresAt(string value) + : base(value) + { + } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationListOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationListOptions.cs new file mode 100644 index 0000000000..f7d8b7375c --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationListOptions.cs @@ -0,0 +1,15 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using Newtonsoft.Json; + + public class RegistrationListOptions : ListOptions + { + /// + /// The status of the Tax Registration. + /// One of: active, all, expired, or scheduled. + /// + [JsonProperty("status")] + public string Status { get; set; } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationService.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationService.cs new file mode 100644 index 0000000000..c157171958 --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationService.cs @@ -0,0 +1,65 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using System.Collections.Generic; + using System.Threading; + using System.Threading.Tasks; + + public class RegistrationService : Service, + ICreatable, + IListable, + IUpdatable + { + public RegistrationService() + : base(null) + { + } + + public RegistrationService(IStripeClient client) + : base(client) + { + } + + public override string BasePath => "/v1/tax/registrations"; + + public virtual Registration Create(RegistrationCreateOptions options, RequestOptions requestOptions = null) + { + return this.CreateEntity(options, requestOptions); + } + + public virtual Task CreateAsync(RegistrationCreateOptions options, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) + { + return this.CreateEntityAsync(options, requestOptions, cancellationToken); + } + + public virtual StripeList List(RegistrationListOptions options = null, RequestOptions requestOptions = null) + { + return this.ListEntities(options, requestOptions); + } + + public virtual Task> ListAsync(RegistrationListOptions options = null, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) + { + return this.ListEntitiesAsync(options, requestOptions, cancellationToken); + } + + public virtual IEnumerable ListAutoPaging(RegistrationListOptions options = null, RequestOptions requestOptions = null) + { + return this.ListEntitiesAutoPaging(options, requestOptions); + } + + public virtual IAsyncEnumerable ListAutoPagingAsync(RegistrationListOptions options = null, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) + { + return this.ListEntitiesAutoPagingAsync(options, requestOptions, cancellationToken); + } + + public virtual Registration Update(string id, RegistrationUpdateOptions options, RequestOptions requestOptions = null) + { + return this.UpdateEntity(id, options, requestOptions); + } + + public virtual Task UpdateAsync(string id, RegistrationUpdateOptions options, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) + { + return this.UpdateEntityAsync(id, options, requestOptions, cancellationToken); + } + } +} diff --git a/src/Stripe.net/Services/Tax/Registrations/RegistrationUpdateOptions.cs b/src/Stripe.net/Services/Tax/Registrations/RegistrationUpdateOptions.cs new file mode 100644 index 0000000000..a96e08418a --- /dev/null +++ b/src/Stripe.net/Services/Tax/Registrations/RegistrationUpdateOptions.cs @@ -0,0 +1,27 @@ +// File generated from our OpenAPI spec +namespace Stripe.Tax +{ + using System; + using Newtonsoft.Json; + using Stripe.Infrastructure; + + public class RegistrationUpdateOptions : BaseOptions + { + /// + /// Time at which the registration becomes active. It can be either now to indicate + /// the current time, or a timestamp measured in seconds since the Unix epoch. + /// + [JsonProperty("active_from")] + [JsonConverter(typeof(AnyOfConverter))] + public AnyOf ActiveFrom { get; set; } + + /// + /// If set, the registration stops being active at this time. If not set, the registration + /// will be active indefinitely. It can be either now to indicate the current time, + /// or a timestamp measured in seconds since the Unix epoch. + /// + [JsonProperty("expires_at")] + [JsonConverter(typeof(AnyOfConverter))] + public AnyOf ExpiresAt { get; set; } + } +}