Update generated code for v633

OPENAPI_VERSION

@@ -1 +1 @@
-v630
+v633

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;
+
+    /// <summary>
+    /// A Tax <c>Registration</c> lets us know that your business is registered to collect tax
+    /// on payments within a region, enabling you to <a
+    /// href="https://stripe.com/docs/tax">automatically collect tax</a>.
+    ///
+    /// Stripe doesn't register on your behalf with the relevant authorities when you create a
+    /// Tax <c>Registration</c> object. For more information on how to register to collect tax,
+    /// see <a href="https://stripe.com/docs/tax/registering">our guide</a>.
+    ///
+    /// Related guide: <a href="https://stripe.com/docs/tax/registrations-api">Using the
+    /// Registrations API</a>.
+    /// </summary>
+    public class Registration : StripeEntity<Registration>, IHasId, IHasObject
+    {
+        /// <summary>
+        /// Unique identifier for the object.
+        /// </summary>
+        [JsonProperty("id")]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// String representing the object's type. Objects of the same type share the same value.
+        /// </summary>
+        [JsonProperty("object")]
+        public string Object { get; set; }
+
+        /// <summary>
+        /// Time at which the registration becomes active. Measured in seconds since the Unix epoch.
+        /// </summary>
+        [JsonProperty("active_from")]
+        [JsonConverter(typeof(UnixDateTimeConverter))]
+        public DateTime ActiveFrom { get; set; } = Stripe.Infrastructure.DateTimeUtils.UnixEpoch;
+
+        /// <summary>
+        /// Two-letter country code (<a href="https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2">ISO
+        /// 3166-1 alpha-2</a>).
+        /// </summary>
+        [JsonProperty("country")]
+        public string Country { get; set; }
+
+        [JsonProperty("country_options")]
+        public RegistrationCountryOptions CountryOptions { get; set; }
+
+        /// <summary>
+        /// Time at which the object was created. Measured in seconds since the Unix epoch.
+        /// </summary>
+        [JsonProperty("created")]
+        [JsonConverter(typeof(UnixDateTimeConverter))]
+        public DateTime Created { get; set; } = Stripe.Infrastructure.DateTimeUtils.UnixEpoch;
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [JsonProperty("expires_at")]
+        [JsonConverter(typeof(UnixDateTimeConverter))]
+        public DateTime? ExpiresAt { get; set; }
+
+        /// <summary>
+        /// Has the value <c>true</c> if the object exists in live mode or the value <c>false</c> if
+        /// the object exists in test mode.
+        /// </summary>
+        [JsonProperty("livemode")]
+        public bool Livemode { get; set; }
+
+        /// <summary>
+        /// The status of the registration. This field is present for convenience and can be deduced
+        /// from <c>active_from</c> and <c>expires_at</c>.
+        /// One of: <c>active</c>, <c>expired</c>, or <c>scheduled</c>.
+        /// </summary>
+        [JsonProperty("status")]
+        public string Status { get; set; }
+    }
+}

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<RegistrationCountryOptions>
+    {
+        [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; }
+    }
+}

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<RegistrationCountryOptionsAe>
+    {
+        /// <summary>
+        /// Type of registration in <c>country</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}

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<RegistrationCountryOptionsAt>
+    {
+        [JsonProperty("standard")]
+        public RegistrationCountryOptionsAtStandard Standard { get; set; }
+
+        /// <summary>
+        /// Type of registration in an EU country.
+        /// One of: <c>ioss</c>, <c>oss_non_union</c>, <c>oss_union</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}

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<RegistrationCountryOptionsAtStandard>
+    {
+        /// <summary>
+        /// Place of supply scheme used in an EU standard registration.
+        /// One of: <c>small_seller</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("place_of_supply_scheme")]
+        public string PlaceOfSupplyScheme { get; set; }
+    }
+}

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<RegistrationCountryOptionsAu>
+    {
+        /// <summary>
+        /// Type of registration in <c>country</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}

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<RegistrationCountryOptionsBe>
+    {
+        [JsonProperty("standard")]
+        public RegistrationCountryOptionsBeStandard Standard { get; set; }
+
+        /// <summary>
+        /// Type of registration in an EU country.
+        /// One of: <c>ioss</c>, <c>oss_non_union</c>, <c>oss_union</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}

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<RegistrationCountryOptionsBeStandard>
+    {
+        /// <summary>
+        /// Place of supply scheme used in an EU standard registration.
+        /// One of: <c>small_seller</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("place_of_supply_scheme")]
+        public string PlaceOfSupplyScheme { get; set; }
+    }
+}

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<RegistrationCountryOptionsBg>
+    {
+        [JsonProperty("standard")]
+        public RegistrationCountryOptionsBgStandard Standard { get; set; }
+
+        /// <summary>
+        /// Type of registration in an EU country.
+        /// One of: <c>ioss</c>, <c>oss_non_union</c>, <c>oss_union</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}

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<RegistrationCountryOptionsBgStandard>
+    {
+        /// <summary>
+        /// Place of supply scheme used in an EU standard registration.
+        /// One of: <c>small_seller</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("place_of_supply_scheme")]
+        public string PlaceOfSupplyScheme { get; set; }
+    }
+}

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<RegistrationCountryOptionsCa>
+    {
+        [JsonProperty("province_standard")]
+        public RegistrationCountryOptionsCaProvinceStandard ProvinceStandard { get; set; }
+
+        /// <summary>
+        /// Type of registration in Canada.
+        /// One of: <c>province_standard</c>, <c>simplified</c>, or <c>standard</c>.
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+    }
+}