diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 141929c0..f3ab3a80 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "4.25.0" + ".": "4.26.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 32f63a30..0fdea26b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 118 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/orb%2Forb-15e42bc01739abea4a925894a1a7de447de40b003a3433461952e8e06919588b.yml -openapi_spec_hash: 8a0bc5b6ab417f7256cbf83d70c459a3 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/orb%2Forb-d0eaf664d43e26c42ebf8740ff1b6ee34c4d424c7048a7f04df994cb65627f89.yml +openapi_spec_hash: 4d7622040380d5c7bd2e5a5ec9b86783 config_hash: 1f73a949b649ecfe6ec68ba1bb459dc2 diff --git a/CHANGELOG.md b/CHANGELOG.md index 0527471b..311c1553 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,18 @@ # Changelog +## 4.26.0 (2025-10-13) + +Full Changelog: [v4.25.0...v4.26.0](https://github.com/orbcorp/orb-python/compare/v4.25.0...v4.26.0) + +### Features + +* **api:** api update ([82b04b7](https://github.com/orbcorp/orb-python/commit/82b04b7a1c56a8a03a4dc469b531b610602afac2)) + + +### Chores + +* **internal:** detect missing future annotations with ruff ([7b70917](https://github.com/orbcorp/orb-python/commit/7b7091726bf0b8b4115e025e775f4e194a2ddf86)) + ## 4.25.0 (2025-10-10) Full Changelog: [v4.24.0...v4.25.0](https://github.com/orbcorp/orb-python/compare/v4.24.0...v4.25.0) diff --git a/pyproject.toml b/pyproject.toml index 124ef966..e84d876a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "orb-billing" -version = "4.25.0" +version = "4.26.0" description = "The official Python library for the orb API" dynamic = ["readme"] license = "Apache-2.0" @@ -224,6 +224,8 @@ select = [ "B", # remove unused imports "F401", + # check for missing future annotations + "FA102", # bare except statements "E722", # unused arguments @@ -246,6 +248,8 @@ unfixable = [ "T203", ] +extend-safe-fixes = ["FA102"] + [tool.ruff.lint.flake8-tidy-imports.banned-api] "functools.lru_cache".msg = "This function does not retain type information for the wrapped function's arguments; The `lru_cache` function from `_utils` should be used instead" diff --git a/src/orb/_version.py b/src/orb/_version.py index 205196a3..9c48ab98 100644 --- a/src/orb/_version.py +++ b/src/orb/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "orb" -__version__ = "4.25.0" # x-release-please-version +__version__ = "4.26.0" # x-release-please-version diff --git a/src/orb/resources/prices/prices.py b/src/orb/resources/prices/prices.py index 902675cf..750f1ecf 100644 --- a/src/orb/resources/prices/prices.py +++ b/src/orb/resources/prices/prices.py @@ -357,6 +357,102 @@ def create( """ ... + @overload + def create( + self, + *, + bulk_with_filters_config: price_create_params.NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig, + cadence: Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"], + currency: str, + item_id: str, + model_type: Literal["bulk_with_filters"], + name: str, + billable_metric_id: Optional[str] | Omit = omit, + billed_in_advance: Optional[bool] | Omit = omit, + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] | Omit = omit, + conversion_rate: Optional[float] | Omit = omit, + conversion_rate_config: Optional[price_create_params.NewFloatingBulkWithFiltersPriceConversionRateConfig] + | Omit = omit, + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] | Omit = omit, + external_price_id: Optional[str] | Omit = omit, + fixed_price_quantity: Optional[float] | Omit = omit, + invoice_grouping_key: Optional[str] | Omit = omit, + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] | Omit = omit, + metadata: Optional[Dict[str, Optional[str]]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> Price: + """ + This endpoint is used to create a [price](/product-catalog/price-configuration). + A price created using this endpoint is always an add-on, meaning that it's not + associated with a specific plan and can instead be individually added to + subscriptions, including subscriptions on different plans. + + An `external_price_id` can be optionally specified as an alias to allow + ergonomic interaction with prices in the Orb API. + + See the [Price resource](/product-catalog/price-configuration) for the + specification of different price model configurations possible in this endpoint. + + Args: + bulk_with_filters_config: Configuration for bulk_with_filters pricing + + cadence: The cadence to bill for this price on. + + currency: An ISO 4217 currency string for which this price is billed in. + + item_id: The id of the item the price will be associated with. + + model_type: The pricing model type + + name: The name of the price. + + billable_metric_id: The id of the billable metric for the price. Only needed if the price is + usage-based. + + billed_in_advance: If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + + billing_cycle_configuration: For custom cadence: specifies the duration of the billing period in days or + months. + + conversion_rate: The per unit conversion rate of the price currency to the invoicing currency. + + conversion_rate_config: The configuration for the rate of the price currency to the invoicing currency. + + dimensional_price_configuration: For dimensional price: specifies a price group and dimension values + + external_price_id: An alias for the price. + + fixed_price_quantity: If the Price represents a fixed cost, this represents the quantity of units + applied. + + invoice_grouping_key: The property used to group this price on an invoice + + invoicing_cycle_configuration: Within each billing cycle, specifies the cadence at which invoices are produced. + If unspecified, a single invoice is produced per billing cycle. + + metadata: User-specified key/value pairs for the resource. Individual keys can be removed + by setting the value to `null`, and the entire metadata mapping can be cleared + by setting `metadata` to `null`. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + ... + @overload def create( self, @@ -2867,6 +2963,7 @@ def create( ["cadence", "currency", "item_id", "model_type", "name", "unit_config"], ["cadence", "currency", "item_id", "model_type", "name", "tiered_config"], ["bulk_config", "cadence", "currency", "item_id", "model_type", "name"], + ["bulk_with_filters_config", "cadence", "currency", "item_id", "model_type", "name"], ["cadence", "currency", "item_id", "model_type", "name", "package_config"], ["cadence", "currency", "item_id", "matrix_config", "model_type", "name"], ["cadence", "currency", "item_id", "model_type", "name", "threshold_total_amount_config"], @@ -2903,6 +3000,7 @@ def create( model_type: Literal["unit"] | Literal["tiered"] | Literal["bulk"] + | Literal["bulk_with_filters"] | Literal["package"] | Literal["matrix"] | Literal["threshold_total_amount"] @@ -2938,6 +3036,7 @@ def create( conversion_rate_config: Optional[price_create_params.NewFloatingUnitPriceConversionRateConfig] | Optional[price_create_params.NewFloatingTieredPriceConversionRateConfig] | Optional[price_create_params.NewFloatingBulkPriceConversionRateConfig] + | Optional[price_create_params.NewFloatingBulkWithFiltersPriceConversionRateConfig] | Optional[price_create_params.NewFloatingPackagePriceConversionRateConfig] | Optional[price_create_params.NewFloatingMatrixPriceConversionRateConfig] | Optional[price_create_params.NewFloatingThresholdTotalAmountPriceConversionRateConfig] @@ -2973,6 +3072,8 @@ def create( metadata: Optional[Dict[str, Optional[str]]] | Omit = omit, tiered_config: TieredConfig | Omit = omit, bulk_config: BulkConfig | Omit = omit, + bulk_with_filters_config: price_create_params.NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig + | Omit = omit, package_config: PackageConfig | Omit = omit, matrix_config: MatrixConfig | Omit = omit, threshold_total_amount_config: price_create_params.NewFloatingThresholdTotalAmountPriceThresholdTotalAmountConfig @@ -3050,6 +3151,7 @@ def create( "metadata": metadata, "tiered_config": tiered_config, "bulk_config": bulk_config, + "bulk_with_filters_config": bulk_with_filters_config, "package_config": package_config, "matrix_config": matrix_config, "threshold_total_amount_config": threshold_total_amount_config, @@ -3807,6 +3909,102 @@ async def create( """ ... + @overload + async def create( + self, + *, + bulk_with_filters_config: price_create_params.NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig, + cadence: Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"], + currency: str, + item_id: str, + model_type: Literal["bulk_with_filters"], + name: str, + billable_metric_id: Optional[str] | Omit = omit, + billed_in_advance: Optional[bool] | Omit = omit, + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] | Omit = omit, + conversion_rate: Optional[float] | Omit = omit, + conversion_rate_config: Optional[price_create_params.NewFloatingBulkWithFiltersPriceConversionRateConfig] + | Omit = omit, + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] | Omit = omit, + external_price_id: Optional[str] | Omit = omit, + fixed_price_quantity: Optional[float] | Omit = omit, + invoice_grouping_key: Optional[str] | Omit = omit, + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] | Omit = omit, + metadata: Optional[Dict[str, Optional[str]]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> Price: + """ + This endpoint is used to create a [price](/product-catalog/price-configuration). + A price created using this endpoint is always an add-on, meaning that it's not + associated with a specific plan and can instead be individually added to + subscriptions, including subscriptions on different plans. + + An `external_price_id` can be optionally specified as an alias to allow + ergonomic interaction with prices in the Orb API. + + See the [Price resource](/product-catalog/price-configuration) for the + specification of different price model configurations possible in this endpoint. + + Args: + bulk_with_filters_config: Configuration for bulk_with_filters pricing + + cadence: The cadence to bill for this price on. + + currency: An ISO 4217 currency string for which this price is billed in. + + item_id: The id of the item the price will be associated with. + + model_type: The pricing model type + + name: The name of the price. + + billable_metric_id: The id of the billable metric for the price. Only needed if the price is + usage-based. + + billed_in_advance: If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + + billing_cycle_configuration: For custom cadence: specifies the duration of the billing period in days or + months. + + conversion_rate: The per unit conversion rate of the price currency to the invoicing currency. + + conversion_rate_config: The configuration for the rate of the price currency to the invoicing currency. + + dimensional_price_configuration: For dimensional price: specifies a price group and dimension values + + external_price_id: An alias for the price. + + fixed_price_quantity: If the Price represents a fixed cost, this represents the quantity of units + applied. + + invoice_grouping_key: The property used to group this price on an invoice + + invoicing_cycle_configuration: Within each billing cycle, specifies the cadence at which invoices are produced. + If unspecified, a single invoice is produced per billing cycle. + + metadata: User-specified key/value pairs for the resource. Individual keys can be removed + by setting the value to `null`, and the entire metadata mapping can be cleared + by setting `metadata` to `null`. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + ... + @overload async def create( self, @@ -6317,6 +6515,7 @@ async def create( ["cadence", "currency", "item_id", "model_type", "name", "unit_config"], ["cadence", "currency", "item_id", "model_type", "name", "tiered_config"], ["bulk_config", "cadence", "currency", "item_id", "model_type", "name"], + ["bulk_with_filters_config", "cadence", "currency", "item_id", "model_type", "name"], ["cadence", "currency", "item_id", "model_type", "name", "package_config"], ["cadence", "currency", "item_id", "matrix_config", "model_type", "name"], ["cadence", "currency", "item_id", "model_type", "name", "threshold_total_amount_config"], @@ -6353,6 +6552,7 @@ async def create( model_type: Literal["unit"] | Literal["tiered"] | Literal["bulk"] + | Literal["bulk_with_filters"] | Literal["package"] | Literal["matrix"] | Literal["threshold_total_amount"] @@ -6388,6 +6588,7 @@ async def create( conversion_rate_config: Optional[price_create_params.NewFloatingUnitPriceConversionRateConfig] | Optional[price_create_params.NewFloatingTieredPriceConversionRateConfig] | Optional[price_create_params.NewFloatingBulkPriceConversionRateConfig] + | Optional[price_create_params.NewFloatingBulkWithFiltersPriceConversionRateConfig] | Optional[price_create_params.NewFloatingPackagePriceConversionRateConfig] | Optional[price_create_params.NewFloatingMatrixPriceConversionRateConfig] | Optional[price_create_params.NewFloatingThresholdTotalAmountPriceConversionRateConfig] @@ -6423,6 +6624,8 @@ async def create( metadata: Optional[Dict[str, Optional[str]]] | Omit = omit, tiered_config: TieredConfig | Omit = omit, bulk_config: BulkConfig | Omit = omit, + bulk_with_filters_config: price_create_params.NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig + | Omit = omit, package_config: PackageConfig | Omit = omit, matrix_config: MatrixConfig | Omit = omit, threshold_total_amount_config: price_create_params.NewFloatingThresholdTotalAmountPriceThresholdTotalAmountConfig @@ -6500,6 +6703,7 @@ async def create( "metadata": metadata, "tiered_config": tiered_config, "bulk_config": bulk_config, + "bulk_with_filters_config": bulk_with_filters_config, "package_config": package_config, "matrix_config": matrix_config, "threshold_total_amount_config": threshold_total_amount_config, diff --git a/src/orb/types/beta/external_plan_id_create_plan_version_params.py b/src/orb/types/beta/external_plan_id_create_plan_version_params.py index 57e95cc3..c6e60525 100644 --- a/src/orb/types/beta/external_plan_id_create_plan_version_params.py +++ b/src/orb/types/beta/external_plan_id_create_plan_version_params.py @@ -49,6 +49,11 @@ "AddAdjustmentAdjustment", "AddPrice", "AddPricePrice", + "AddPricePriceNewPlanBulkWithFiltersPrice", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier", + "AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig", "AddPricePriceNewPlanTieredWithProrationPrice", "AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfig", "AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier", @@ -68,6 +73,11 @@ "ReplaceAdjustmentAdjustment", "ReplacePrice", "ReplacePricePrice", + "ReplacePricePriceNewPlanBulkWithFiltersPrice", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier", + "ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig", "ReplacePricePriceNewPlanTieredWithProrationPrice", "ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfig", "ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier", @@ -123,6 +133,116 @@ class AddAdjustment(TypedDict, total=False): """The phase to add this adjustment to.""" +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class AddPricePriceNewPlanBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -519,6 +639,7 @@ class AddPricePriceNewPlanEventOutputPrice(TypedDict, total=False): NewPlanUnitPrice, NewPlanTieredPrice, NewPlanBulkPrice, + AddPricePriceNewPlanBulkWithFiltersPrice, NewPlanPackagePrice, NewPlanMatrixPrice, NewPlanThresholdTotalAmountPrice, @@ -591,6 +712,116 @@ class ReplaceAdjustment(TypedDict, total=False): """The phase to replace this adjustment from.""" +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class ReplacePricePriceNewPlanBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -987,6 +1218,7 @@ class ReplacePricePriceNewPlanEventOutputPrice(TypedDict, total=False): NewPlanUnitPrice, NewPlanTieredPrice, NewPlanBulkPrice, + ReplacePricePriceNewPlanBulkWithFiltersPrice, NewPlanPackagePrice, NewPlanMatrixPrice, NewPlanThresholdTotalAmountPrice, diff --git a/src/orb/types/beta_create_plan_version_params.py b/src/orb/types/beta_create_plan_version_params.py index c2bbf77f..26adecd8 100644 --- a/src/orb/types/beta_create_plan_version_params.py +++ b/src/orb/types/beta_create_plan_version_params.py @@ -49,6 +49,11 @@ "AddAdjustmentAdjustment", "AddPrice", "AddPricePrice", + "AddPricePriceNewPlanBulkWithFiltersPrice", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier", + "AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig", "AddPricePriceNewPlanTieredWithProrationPrice", "AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfig", "AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier", @@ -68,6 +73,11 @@ "ReplaceAdjustmentAdjustment", "ReplacePrice", "ReplacePricePrice", + "ReplacePricePriceNewPlanBulkWithFiltersPrice", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier", + "ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig", "ReplacePricePriceNewPlanTieredWithProrationPrice", "ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfig", "ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier", @@ -123,6 +133,116 @@ class AddAdjustment(TypedDict, total=False): """The phase to add this adjustment to.""" +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class AddPricePriceNewPlanBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[AddPricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[AddPricePriceNewPlanBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class AddPricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -519,6 +639,7 @@ class AddPricePriceNewPlanEventOutputPrice(TypedDict, total=False): NewPlanUnitPrice, NewPlanTieredPrice, NewPlanBulkPrice, + AddPricePriceNewPlanBulkWithFiltersPrice, NewPlanPackagePrice, NewPlanMatrixPrice, NewPlanThresholdTotalAmountPrice, @@ -591,6 +712,116 @@ class ReplaceAdjustment(TypedDict, total=False): """The phase to replace this adjustment from.""" +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class ReplacePricePriceNewPlanBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[ReplacePricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[ReplacePricePriceNewPlanBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class ReplacePricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -987,6 +1218,7 @@ class ReplacePricePriceNewPlanEventOutputPrice(TypedDict, total=False): NewPlanUnitPrice, NewPlanTieredPrice, NewPlanBulkPrice, + ReplacePricePriceNewPlanBulkWithFiltersPrice, NewPlanPackagePrice, NewPlanMatrixPrice, NewPlanThresholdTotalAmountPrice, diff --git a/src/orb/types/plan_create_params.py b/src/orb/types/plan_create_params.py index 635d32ec..c58cba71 100644 --- a/src/orb/types/plan_create_params.py +++ b/src/orb/types/plan_create_params.py @@ -47,6 +47,11 @@ "PlanCreateParams", "Price", "PricePrice", + "PricePriceNewPlanBulkWithFiltersPrice", + "PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig", + "PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier", + "PricePriceNewPlanBulkWithFiltersPriceConversionRateConfig", "PricePriceNewPlanTieredWithProrationPrice", "PricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfig", "PricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier", @@ -121,6 +126,116 @@ class PlanCreateParams(TypedDict, total=False): """ +class PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +PricePriceNewPlanBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class PricePriceNewPlanBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[PricePriceNewPlanBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[PricePriceNewPlanBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class PricePriceNewPlanTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -517,6 +632,7 @@ class PricePriceNewPlanEventOutputPrice(TypedDict, total=False): NewPlanUnitPrice, NewPlanTieredPrice, NewPlanBulkPrice, + PricePriceNewPlanBulkWithFiltersPrice, NewPlanPackagePrice, NewPlanMatrixPrice, NewPlanThresholdTotalAmountPrice, diff --git a/src/orb/types/price_create_params.py b/src/orb/types/price_create_params.py index fbbb0ccb..daad783d 100644 --- a/src/orb/types/price_create_params.py +++ b/src/orb/types/price_create_params.py @@ -24,6 +24,11 @@ "NewFloatingTieredPriceConversionRateConfig", "NewFloatingBulkPrice", "NewFloatingBulkPriceConversionRateConfig", + "NewFloatingBulkWithFiltersPrice", + "NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig", + "NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier", + "NewFloatingBulkWithFiltersPriceConversionRateConfig", "NewFloatingPackagePrice", "NewFloatingPackagePriceConversionRateConfig", "NewFloatingMatrixPrice", @@ -343,6 +348,107 @@ class NewFloatingBulkPrice(TypedDict, total=False): NewFloatingBulkPriceConversionRateConfig: TypeAlias = Union[UnitConversionRateConfig, TieredConversionRateConfig] +class NewFloatingBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + currency: Required[str] + """An ISO 4217 currency string for which this price is billed in.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[NewFloatingBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + +class NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class NewFloatingBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[NewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +NewFloatingBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + class NewFloatingPackagePrice(TypedDict, total=False): cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] """The cadence to bill for this price on.""" @@ -2769,6 +2875,7 @@ class NewFloatingEventOutputPriceEventOutputConfig(TypedDict, total=False): NewFloatingUnitPrice, NewFloatingTieredPrice, NewFloatingBulkPrice, + NewFloatingBulkWithFiltersPrice, NewFloatingPackagePrice, NewFloatingMatrixPrice, NewFloatingThresholdTotalAmountPrice, diff --git a/src/orb/types/price_evaluate_multiple_params.py b/src/orb/types/price_evaluate_multiple_params.py index b1ff2a84..15554dec 100644 --- a/src/orb/types/price_evaluate_multiple_params.py +++ b/src/orb/types/price_evaluate_multiple_params.py @@ -47,6 +47,11 @@ "PriceEvaluateMultipleParams", "PriceEvaluation", "PriceEvaluationPrice", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPrice", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPrice", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceConversionRateConfig", @@ -76,6 +81,107 @@ class PriceEvaluateMultipleParams(TypedDict, total=False): """List of prices to evaluate (max 100)""" +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + currency: Required[str] + """An ISO 4217 currency string for which this price is billed in.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + class PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig( TypedDict, total=False ): @@ -347,6 +453,7 @@ class PriceEvaluationPriceNewFloatingEventOutputPrice(TypedDict, total=False): NewFloatingUnitPrice, NewFloatingTieredPrice, NewFloatingBulkPrice, + PriceEvaluationPriceNewFloatingBulkWithFiltersPrice, NewFloatingPackagePrice, NewFloatingMatrixPrice, NewFloatingThresholdTotalAmountPrice, diff --git a/src/orb/types/price_evaluate_preview_events_params.py b/src/orb/types/price_evaluate_preview_events_params.py index b96b93d9..ac91d16e 100644 --- a/src/orb/types/price_evaluate_preview_events_params.py +++ b/src/orb/types/price_evaluate_preview_events_params.py @@ -48,6 +48,11 @@ "Event", "PriceEvaluation", "PriceEvaluationPrice", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPrice", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier", + "PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPrice", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig", "PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceConversionRateConfig", @@ -108,6 +113,107 @@ class Event(TypedDict, total=False): """ +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class PriceEvaluationPriceNewFloatingBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + currency: Required[str] + """An ISO 4217 currency string for which this price is billed in.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[PriceEvaluationPriceNewFloatingBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + class PriceEvaluationPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig( TypedDict, total=False ): @@ -379,6 +485,7 @@ class PriceEvaluationPriceNewFloatingEventOutputPrice(TypedDict, total=False): NewFloatingUnitPrice, NewFloatingTieredPrice, NewFloatingBulkPrice, + PriceEvaluationPriceNewFloatingBulkWithFiltersPrice, NewFloatingPackagePrice, NewFloatingMatrixPrice, NewFloatingThresholdTotalAmountPrice, diff --git a/src/orb/types/shared/price.py b/src/orb/types/shared/price.py index 825c9745..49773efa 100644 --- a/src/orb/types/shared/price.py +++ b/src/orb/types/shared/price.py @@ -34,6 +34,11 @@ "TieredPriceConversionRateConfig", "BulkPrice", "BulkPriceConversionRateConfig", + "BulkWithFiltersPrice", + "BulkWithFiltersPriceBulkWithFiltersConfig", + "BulkWithFiltersPriceBulkWithFiltersConfigFilter", + "BulkWithFiltersPriceBulkWithFiltersConfigTier", + "BulkWithFiltersPriceConversionRateConfig", "PackagePrice", "PackagePriceConversionRateConfig", "MatrixPrice", @@ -364,6 +369,109 @@ class BulkPrice(BaseModel): dimensional_price_configuration: Optional[DimensionalPriceConfiguration] = None +class BulkWithFiltersPriceBulkWithFiltersConfigFilter(BaseModel): + property_key: str + """Event property key to filter on""" + + property_value: str + """Event property value to match""" + + +class BulkWithFiltersPriceBulkWithFiltersConfigTier(BaseModel): + unit_amount: str + """Amount per unit""" + + tier_lower_bound: Optional[str] = None + """The lower bound for this tier""" + + +class BulkWithFiltersPriceBulkWithFiltersConfig(BaseModel): + filters: List[BulkWithFiltersPriceBulkWithFiltersConfigFilter] + """Property filters to apply (all must match)""" + + tiers: List[BulkWithFiltersPriceBulkWithFiltersConfigTier] + """Bulk tiers for rating based on total usage volume""" + + +BulkWithFiltersPriceConversionRateConfig: TypeAlias = Annotated[ + Union[UnitConversionRateConfig, TieredConversionRateConfig], PropertyInfo(discriminator="conversion_rate_type") +] + + +class BulkWithFiltersPrice(BaseModel): + id: str + + billable_metric: Optional[BillableMetricTiny] = None + + billing_cycle_configuration: BillingCycleConfiguration + + billing_mode: Literal["in_advance", "in_arrear"] + + bulk_with_filters_config: BulkWithFiltersPriceBulkWithFiltersConfig + """Configuration for bulk_with_filters pricing""" + + cadence: Literal["one_time", "monthly", "quarterly", "semi_annual", "annual", "custom"] + + composite_price_filters: Optional[List[TransformPriceFilter]] = None + + conversion_rate: Optional[float] = None + + conversion_rate_config: Optional[BulkWithFiltersPriceConversionRateConfig] = None + + created_at: datetime + + credit_allocation: Optional[Allocation] = None + + currency: str + + discount: Optional[Discount] = None + + external_price_id: Optional[str] = None + + fixed_price_quantity: Optional[float] = None + + invoicing_cycle_configuration: Optional[BillingCycleConfiguration] = None + + item: ItemSlim + """ + A minimal representation of an Item containing only the essential identifying + information. + """ + + maximum: Optional[Maximum] = None + + maximum_amount: Optional[str] = None + + metadata: Dict[str, str] + """User specified key-value pairs for the resource. + + If not present, this defaults to an empty dictionary. Individual keys can be + removed by setting the value to `null`, and the entire metadata mapping can be + cleared by setting `metadata` to `null`. + """ + + minimum: Optional[Minimum] = None + + minimum_amount: Optional[str] = None + + price_model_type: Literal["bulk_with_filters"] = FieldInfo(alias="model_type") + """The pricing model type""" + + name: str + + plan_phase_order: Optional[int] = None + + price_type: Literal["usage_price", "fixed_price", "composite_price"] + + replaces_price_id: Optional[str] = None + """The price id this price replaces. + + This price will take the place of the replaced price in plan version migrations. + """ + + dimensional_price_configuration: Optional[DimensionalPriceConfiguration] = None + + PackagePriceConversionRateConfig: TypeAlias = Annotated[ Union[UnitConversionRateConfig, TieredConversionRateConfig], PropertyInfo(discriminator="conversion_rate_type") ] @@ -2832,6 +2940,7 @@ class EventOutputPrice(BaseModel): UnitPrice, TieredPrice, BulkPrice, + BulkWithFiltersPrice, PackagePrice, MatrixPrice, ThresholdTotalAmountPrice, diff --git a/src/orb/types/subscription_create_params.py b/src/orb/types/subscription_create_params.py index d626ed02..992e0079 100644 --- a/src/orb/types/subscription_create_params.py +++ b/src/orb/types/subscription_create_params.py @@ -60,6 +60,11 @@ "AddAdjustmentAdjustment", "AddPrice", "AddPricePrice", + "AddPricePriceNewSubscriptionBulkWithFiltersPrice", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig", "AddPricePriceNewSubscriptionTieredWithProrationPrice", "AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfig", "AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier", @@ -79,6 +84,11 @@ "ReplaceAdjustmentAdjustment", "ReplacePrice", "ReplacePricePrice", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPrice", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig", "ReplacePricePriceNewSubscriptionTieredWithProrationPrice", "ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfig", "ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier", @@ -292,6 +302,116 @@ class AddAdjustment(TypedDict, total=False): """ +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class AddPricePriceNewSubscriptionBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -692,6 +812,7 @@ class AddPricePriceNewSubscriptionEventOutputPrice(TypedDict, total=False): NewSubscriptionUnitPriceParam, NewSubscriptionTieredPriceParam, NewSubscriptionBulkPriceParam, + AddPricePriceNewSubscriptionBulkWithFiltersPrice, NewSubscriptionPackagePriceParam, NewSubscriptionMatrixPriceParam, NewSubscriptionThresholdTotalAmountPriceParam, @@ -796,6 +917,116 @@ class ReplaceAdjustment(TypedDict, total=False): """The id of the adjustment on the plan to replace in the subscription.""" +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -1198,6 +1429,7 @@ class ReplacePricePriceNewSubscriptionEventOutputPrice(TypedDict, total=False): NewSubscriptionUnitPriceParam, NewSubscriptionTieredPriceParam, NewSubscriptionBulkPriceParam, + ReplacePricePriceNewSubscriptionBulkWithFiltersPrice, NewSubscriptionPackagePriceParam, NewSubscriptionMatrixPriceParam, NewSubscriptionThresholdTotalAmountPriceParam, diff --git a/src/orb/types/subscription_price_intervals_params.py b/src/orb/types/subscription_price_intervals_params.py index a07c7421..432d2516 100644 --- a/src/orb/types/subscription_price_intervals_params.py +++ b/src/orb/types/subscription_price_intervals_params.py @@ -59,6 +59,11 @@ "AddDiscountUsageDiscountCreationParams", "AddFixedFeeQuantityTransition", "AddPrice", + "AddPriceNewFloatingBulkWithFiltersPrice", + "AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig", + "AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier", + "AddPriceNewFloatingBulkWithFiltersPriceConversionRateConfig", "AddPriceNewFloatingGroupedWithMinMaxThresholdsPrice", "AddPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig", "AddPriceNewFloatingGroupedWithMinMaxThresholdsPriceConversionRateConfig", @@ -139,6 +144,107 @@ class AddFixedFeeQuantityTransition(TypedDict, total=False): """The quantity of the fixed fee quantity transition.""" +class AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +AddPriceNewFloatingBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class AddPriceNewFloatingBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[AddPriceNewFloatingBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + currency: Required[str] + """An ISO 4217 currency string for which this price is billed in.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[AddPriceNewFloatingBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + class AddPriceNewFloatingGroupedWithMinMaxThresholdsPriceGroupedWithMinMaxThresholdsConfig(TypedDict, total=False): grouping_key: Required[str] """The event property used to group before applying thresholds""" @@ -406,6 +512,7 @@ class AddPriceNewFloatingEventOutputPrice(TypedDict, total=False): NewFloatingUnitPrice, NewFloatingTieredPrice, NewFloatingBulkPrice, + AddPriceNewFloatingBulkWithFiltersPrice, NewFloatingPackagePrice, NewFloatingMatrixPrice, NewFloatingThresholdTotalAmountPrice, diff --git a/src/orb/types/subscription_schedule_plan_change_params.py b/src/orb/types/subscription_schedule_plan_change_params.py index 3dc830f4..40418eb9 100644 --- a/src/orb/types/subscription_schedule_plan_change_params.py +++ b/src/orb/types/subscription_schedule_plan_change_params.py @@ -60,6 +60,11 @@ "AddAdjustmentAdjustment", "AddPrice", "AddPricePrice", + "AddPricePriceNewSubscriptionBulkWithFiltersPrice", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier", + "AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig", "AddPricePriceNewSubscriptionTieredWithProrationPrice", "AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfig", "AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier", @@ -79,6 +84,11 @@ "ReplaceAdjustmentAdjustment", "ReplacePrice", "ReplacePricePrice", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPrice", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier", + "ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig", "ReplacePricePriceNewSubscriptionTieredWithProrationPrice", "ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfig", "ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier", @@ -280,6 +290,116 @@ class AddAdjustment(TypedDict, total=False): """ +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class AddPricePriceNewSubscriptionBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[AddPricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[AddPricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class AddPricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -680,6 +800,7 @@ class AddPricePriceNewSubscriptionEventOutputPrice(TypedDict, total=False): NewSubscriptionUnitPriceParam, NewSubscriptionTieredPriceParam, NewSubscriptionBulkPriceParam, + AddPricePriceNewSubscriptionBulkWithFiltersPrice, NewSubscriptionPackagePriceParam, NewSubscriptionMatrixPriceParam, NewSubscriptionThresholdTotalAmountPriceParam, @@ -784,6 +905,116 @@ class ReplaceAdjustment(TypedDict, total=False): """The id of the adjustment on the plan to replace in the subscription.""" +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter(TypedDict, total=False): + property_key: Required[str] + """Event property key to filter on""" + + property_value: Required[str] + """Event property value to match""" + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier(TypedDict, total=False): + unit_amount: Required[str] + """Amount per unit""" + + tier_lower_bound: Optional[str] + """The lower bound for this tier""" + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig(TypedDict, total=False): + filters: Required[Iterable[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigFilter]] + """Property filters to apply (all must match)""" + + tiers: Required[Iterable[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfigTier]] + """Bulk tiers for rating based on total usage volume""" + + +ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig: TypeAlias = Union[ + UnitConversionRateConfig, TieredConversionRateConfig +] + + +class ReplacePricePriceNewSubscriptionBulkWithFiltersPrice(TypedDict, total=False): + bulk_with_filters_config: Required[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceBulkWithFiltersConfig] + """Configuration for bulk_with_filters pricing""" + + cadence: Required[Literal["annual", "semi_annual", "monthly", "quarterly", "one_time", "custom"]] + """The cadence to bill for this price on.""" + + item_id: Required[str] + """The id of the item the price will be associated with.""" + + model_type: Required[Literal["bulk_with_filters"]] + """The pricing model type""" + + name: Required[str] + """The name of the price.""" + + billable_metric_id: Optional[str] + """The id of the billable metric for the price. + + Only needed if the price is usage-based. + """ + + billed_in_advance: Optional[bool] + """ + If the Price represents a fixed cost, the price will be billed in-advance if + this is true, and in-arrears if this is false. + """ + + billing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """ + For custom cadence: specifies the duration of the billing period in days or + months. + """ + + conversion_rate: Optional[float] + """The per unit conversion rate of the price currency to the invoicing currency.""" + + conversion_rate_config: Optional[ReplacePricePriceNewSubscriptionBulkWithFiltersPriceConversionRateConfig] + """The configuration for the rate of the price currency to the invoicing currency.""" + + currency: Optional[str] + """ + An ISO 4217 currency string, or custom pricing unit identifier, in which this + price is billed. + """ + + dimensional_price_configuration: Optional[NewDimensionalPriceConfiguration] + """For dimensional price: specifies a price group and dimension values""" + + external_price_id: Optional[str] + """An alias for the price.""" + + fixed_price_quantity: Optional[float] + """ + If the Price represents a fixed cost, this represents the quantity of units + applied. + """ + + invoice_grouping_key: Optional[str] + """The property used to group this price on an invoice""" + + invoicing_cycle_configuration: Optional[NewBillingCycleConfiguration] + """Within each billing cycle, specifies the cadence at which invoices are produced. + + If unspecified, a single invoice is produced per billing cycle. + """ + + metadata: Optional[Dict[str, Optional[str]]] + """User-specified key/value pairs for the resource. + + Individual keys can be removed by setting the value to `null`, and the entire + metadata mapping can be cleared by setting `metadata` to `null`. + """ + + reference_id: Optional[str] + """ + A transient ID that can be used to reference this price when adding adjustments + in the same API call. + """ + + class ReplacePricePriceNewSubscriptionTieredWithProrationPriceTieredWithProrationConfigTier(TypedDict, total=False): tier_lower_bound: Required[str] """Inclusive tier starting value""" @@ -1186,6 +1417,7 @@ class ReplacePricePriceNewSubscriptionEventOutputPrice(TypedDict, total=False): NewSubscriptionUnitPriceParam, NewSubscriptionTieredPriceParam, NewSubscriptionBulkPriceParam, + ReplacePricePriceNewSubscriptionBulkWithFiltersPrice, NewSubscriptionPackagePriceParam, NewSubscriptionMatrixPriceParam, NewSubscriptionThresholdTotalAmountPriceParam, diff --git a/tests/api_resources/test_prices.py b/tests/api_resources/test_prices.py index ae0b56bd..c4cb6031 100644 --- a/tests/api_resources/test_prices.py +++ b/tests/api_resources/test_prices.py @@ -308,6 +308,129 @@ def test_streaming_response_create_overload_3(self, client: Orb) -> None: @parametrize def test_method_create_overload_4(self, client: Orb) -> None: + price = client.prices.create( + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk_with_filters", + name="Annual fee", + ) + assert_matches_type(Price, price, path=["response"]) + + @parametrize + def test_method_create_with_all_params_overload_4(self, client: Orb) -> None: + price = client.prices.create( + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [ + { + "unit_amount": "unit_amount", + "tier_lower_bound": "tier_lower_bound", + }, + { + "unit_amount": "unit_amount", + "tier_lower_bound": "tier_lower_bound", + }, + ], + }, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk_with_filters", + name="Annual fee", + billable_metric_id="billable_metric_id", + billed_in_advance=True, + billing_cycle_configuration={ + "duration": 0, + "duration_unit": "day", + }, + conversion_rate=0, + conversion_rate_config={ + "conversion_rate_type": "unit", + "unit_config": {"unit_amount": "unit_amount"}, + }, + dimensional_price_configuration={ + "dimension_values": ["string"], + "dimensional_price_group_id": "dimensional_price_group_id", + "external_dimensional_price_group_id": "external_dimensional_price_group_id", + }, + external_price_id="external_price_id", + fixed_price_quantity=0, + invoice_grouping_key="x", + invoicing_cycle_configuration={ + "duration": 0, + "duration_unit": "day", + }, + metadata={"foo": "string"}, + ) + assert_matches_type(Price, price, path=["response"]) + + @parametrize + def test_raw_response_create_overload_4(self, client: Orb) -> None: + response = client.prices.with_raw_response.create( + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk_with_filters", + name="Annual fee", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + price = response.parse() + assert_matches_type(Price, price, path=["response"]) + + @parametrize + def test_streaming_response_create_overload_4(self, client: Orb) -> None: + with client.prices.with_streaming_response.create( + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk_with_filters", + name="Annual fee", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + price = response.parse() + assert_matches_type(Price, price, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_create_overload_5(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -322,7 +445,7 @@ def test_method_create_overload_4(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_4(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_5(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -361,7 +484,7 @@ def test_method_create_with_all_params_overload_4(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_4(self, client: Orb) -> None: + def test_raw_response_create_overload_5(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -380,7 +503,7 @@ def test_raw_response_create_overload_4(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_4(self, client: Orb) -> None: + def test_streaming_response_create_overload_5(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -401,7 +524,7 @@ def test_streaming_response_create_overload_4(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_5(self, client: Orb) -> None: + def test_method_create_overload_6(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -422,7 +545,7 @@ def test_method_create_overload_5(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_5(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_6(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -467,7 +590,7 @@ def test_method_create_with_all_params_overload_5(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_5(self, client: Orb) -> None: + def test_raw_response_create_overload_6(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -492,7 +615,7 @@ def test_raw_response_create_overload_5(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_5(self, client: Orb) -> None: + def test_streaming_response_create_overload_6(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -519,7 +642,7 @@ def test_streaming_response_create_overload_5(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_6(self, client: Orb) -> None: + def test_method_create_overload_7(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -542,7 +665,7 @@ def test_method_create_overload_6(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_6(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_7(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -590,7 +713,7 @@ def test_method_create_with_all_params_overload_6(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_6(self, client: Orb) -> None: + def test_raw_response_create_overload_7(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -617,7 +740,7 @@ def test_raw_response_create_overload_6(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_6(self, client: Orb) -> None: + def test_streaming_response_create_overload_7(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -646,7 +769,7 @@ def test_streaming_response_create_overload_6(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_7(self, client: Orb) -> None: + def test_method_create_overload_8(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -670,7 +793,7 @@ def test_method_create_overload_7(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_7(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_8(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -718,7 +841,7 @@ def test_method_create_with_all_params_overload_7(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_7(self, client: Orb) -> None: + def test_raw_response_create_overload_8(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -746,7 +869,7 @@ def test_raw_response_create_overload_7(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_7(self, client: Orb) -> None: + def test_streaming_response_create_overload_8(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -776,7 +899,7 @@ def test_streaming_response_create_overload_7(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_8(self, client: Orb) -> None: + def test_method_create_overload_9(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -801,7 +924,7 @@ def test_method_create_overload_8(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_8(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_9(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -852,7 +975,7 @@ def test_method_create_with_all_params_overload_8(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_8(self, client: Orb) -> None: + def test_raw_response_create_overload_9(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -881,7 +1004,7 @@ def test_raw_response_create_overload_8(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_8(self, client: Orb) -> None: + def test_streaming_response_create_overload_9(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -912,7 +1035,7 @@ def test_streaming_response_create_overload_8(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_9(self, client: Orb) -> None: + def test_method_create_overload_10(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -936,7 +1059,7 @@ def test_method_create_overload_9(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_9(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_10(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -984,7 +1107,7 @@ def test_method_create_with_all_params_overload_9(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_9(self, client: Orb) -> None: + def test_raw_response_create_overload_10(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1012,7 +1135,7 @@ def test_raw_response_create_overload_9(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_9(self, client: Orb) -> None: + def test_streaming_response_create_overload_10(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1042,7 +1165,7 @@ def test_streaming_response_create_overload_9(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_10(self, client: Orb) -> None: + def test_method_create_overload_11(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1068,7 +1191,7 @@ def test_method_create_overload_10(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_10(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_11(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1118,7 +1241,7 @@ def test_method_create_with_all_params_overload_10(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_10(self, client: Orb) -> None: + def test_raw_response_create_overload_11(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1148,7 +1271,7 @@ def test_raw_response_create_overload_10(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_10(self, client: Orb) -> None: + def test_streaming_response_create_overload_11(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1180,7 +1303,7 @@ def test_streaming_response_create_overload_10(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_11(self, client: Orb) -> None: + def test_method_create_overload_12(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1196,7 +1319,7 @@ def test_method_create_overload_11(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_11(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_12(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1236,7 +1359,7 @@ def test_method_create_with_all_params_overload_11(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_11(self, client: Orb) -> None: + def test_raw_response_create_overload_12(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1256,7 +1379,7 @@ def test_raw_response_create_overload_11(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_11(self, client: Orb) -> None: + def test_streaming_response_create_overload_12(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1278,7 +1401,7 @@ def test_streaming_response_create_overload_11(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_12(self, client: Orb) -> None: + def test_method_create_overload_13(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1293,7 +1416,7 @@ def test_method_create_overload_12(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_12(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_13(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1332,7 +1455,7 @@ def test_method_create_with_all_params_overload_12(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_12(self, client: Orb) -> None: + def test_raw_response_create_overload_13(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1351,7 +1474,7 @@ def test_raw_response_create_overload_12(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_12(self, client: Orb) -> None: + def test_streaming_response_create_overload_13(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1372,7 +1495,7 @@ def test_streaming_response_create_overload_12(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_13(self, client: Orb) -> None: + def test_method_create_overload_14(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1394,7 +1517,7 @@ def test_method_create_overload_13(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_13(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_14(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1440,7 +1563,7 @@ def test_method_create_with_all_params_overload_13(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_13(self, client: Orb) -> None: + def test_raw_response_create_overload_14(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1466,7 +1589,7 @@ def test_raw_response_create_overload_13(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_13(self, client: Orb) -> None: + def test_streaming_response_create_overload_14(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1494,7 +1617,7 @@ def test_streaming_response_create_overload_13(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_14(self, client: Orb) -> None: + def test_method_create_overload_15(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1513,7 +1636,7 @@ def test_method_create_overload_14(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_14(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_15(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1556,7 +1679,7 @@ def test_method_create_with_all_params_overload_14(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_14(self, client: Orb) -> None: + def test_raw_response_create_overload_15(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1579,7 +1702,7 @@ def test_raw_response_create_overload_14(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_14(self, client: Orb) -> None: + def test_streaming_response_create_overload_15(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1604,7 +1727,7 @@ def test_streaming_response_create_overload_14(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_15(self, client: Orb) -> None: + def test_method_create_overload_16(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1616,7 +1739,7 @@ def test_method_create_overload_15(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_15(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_16(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1652,7 +1775,7 @@ def test_method_create_with_all_params_overload_15(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_15(self, client: Orb) -> None: + def test_raw_response_create_overload_16(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1668,7 +1791,7 @@ def test_raw_response_create_overload_15(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_15(self, client: Orb) -> None: + def test_streaming_response_create_overload_16(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1686,7 +1809,7 @@ def test_streaming_response_create_overload_15(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_16(self, client: Orb) -> None: + def test_method_create_overload_17(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1702,7 +1825,7 @@ def test_method_create_overload_16(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_16(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_17(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1742,7 +1865,7 @@ def test_method_create_with_all_params_overload_16(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_16(self, client: Orb) -> None: + def test_raw_response_create_overload_17(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1762,7 +1885,7 @@ def test_raw_response_create_overload_16(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_16(self, client: Orb) -> None: + def test_streaming_response_create_overload_17(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1784,7 +1907,7 @@ def test_streaming_response_create_overload_16(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_17(self, client: Orb) -> None: + def test_method_create_overload_18(self, client: Orb) -> None: price = client.prices.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -1796,7 +1919,7 @@ def test_method_create_overload_17(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_17(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_18(self, client: Orb) -> None: price = client.prices.create( bulk_with_proration_config={ "tiers": [ @@ -1843,7 +1966,7 @@ def test_method_create_with_all_params_overload_17(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_17(self, client: Orb) -> None: + def test_raw_response_create_overload_18(self, client: Orb) -> None: response = client.prices.with_raw_response.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -1859,7 +1982,7 @@ def test_raw_response_create_overload_17(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_17(self, client: Orb) -> None: + def test_streaming_response_create_overload_18(self, client: Orb) -> None: with client.prices.with_streaming_response.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -1877,7 +2000,7 @@ def test_streaming_response_create_overload_17(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_18(self, client: Orb) -> None: + def test_method_create_overload_19(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1893,7 +2016,7 @@ def test_method_create_overload_18(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_18(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_19(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -1933,7 +2056,7 @@ def test_method_create_with_all_params_overload_18(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_18(self, client: Orb) -> None: + def test_raw_response_create_overload_19(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -1953,7 +2076,7 @@ def test_raw_response_create_overload_18(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_18(self, client: Orb) -> None: + def test_streaming_response_create_overload_19(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -1975,7 +2098,7 @@ def test_streaming_response_create_overload_18(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_19(self, client: Orb) -> None: + def test_method_create_overload_20(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2004,7 +2127,7 @@ def test_method_create_overload_19(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_19(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_20(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2057,7 +2180,7 @@ def test_method_create_with_all_params_overload_19(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_19(self, client: Orb) -> None: + def test_raw_response_create_overload_20(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2090,7 +2213,7 @@ def test_raw_response_create_overload_19(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_19(self, client: Orb) -> None: + def test_streaming_response_create_overload_20(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2125,7 +2248,7 @@ def test_streaming_response_create_overload_19(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_20(self, client: Orb) -> None: + def test_method_create_overload_21(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2142,7 +2265,7 @@ def test_method_create_overload_20(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_20(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_21(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2183,7 +2306,7 @@ def test_method_create_with_all_params_overload_20(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_20(self, client: Orb) -> None: + def test_raw_response_create_overload_21(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2204,7 +2327,7 @@ def test_raw_response_create_overload_20(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_20(self, client: Orb) -> None: + def test_streaming_response_create_overload_21(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2227,7 +2350,7 @@ def test_streaming_response_create_overload_20(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_21(self, client: Orb) -> None: + def test_method_create_overload_22(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2248,7 +2371,7 @@ def test_method_create_overload_21(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_21(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_22(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2293,7 +2416,7 @@ def test_method_create_with_all_params_overload_21(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_21(self, client: Orb) -> None: + def test_raw_response_create_overload_22(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2318,7 +2441,7 @@ def test_raw_response_create_overload_21(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_21(self, client: Orb) -> None: + def test_streaming_response_create_overload_22(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2345,7 +2468,7 @@ def test_streaming_response_create_overload_21(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_22(self, client: Orb) -> None: + def test_method_create_overload_23(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2370,7 +2493,7 @@ def test_method_create_overload_22(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_22(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_23(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2419,7 +2542,7 @@ def test_method_create_with_all_params_overload_22(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_22(self, client: Orb) -> None: + def test_raw_response_create_overload_23(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2448,7 +2571,7 @@ def test_raw_response_create_overload_22(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_22(self, client: Orb) -> None: + def test_streaming_response_create_overload_23(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2479,7 +2602,7 @@ def test_streaming_response_create_overload_22(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_23(self, client: Orb) -> None: + def test_method_create_overload_24(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2504,7 +2627,7 @@ def test_method_create_overload_23(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_23(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_24(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2553,7 +2676,7 @@ def test_method_create_with_all_params_overload_23(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_23(self, client: Orb) -> None: + def test_raw_response_create_overload_24(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2582,7 +2705,7 @@ def test_raw_response_create_overload_23(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_23(self, client: Orb) -> None: + def test_streaming_response_create_overload_24(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2613,7 +2736,7 @@ def test_streaming_response_create_overload_23(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_24(self, client: Orb) -> None: + def test_method_create_overload_25(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2634,7 +2757,7 @@ def test_method_create_overload_24(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_24(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_25(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2682,7 +2805,7 @@ def test_method_create_with_all_params_overload_24(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_24(self, client: Orb) -> None: + def test_raw_response_create_overload_25(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2707,7 +2830,7 @@ def test_raw_response_create_overload_24(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_24(self, client: Orb) -> None: + def test_streaming_response_create_overload_25(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2734,7 +2857,7 @@ def test_streaming_response_create_overload_24(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_25(self, client: Orb) -> None: + def test_method_create_overload_26(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2764,7 +2887,7 @@ def test_method_create_overload_25(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_25(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_26(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -2820,7 +2943,7 @@ def test_method_create_with_all_params_overload_25(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_25(self, client: Orb) -> None: + def test_raw_response_create_overload_26(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -2854,7 +2977,7 @@ def test_raw_response_create_overload_25(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_25(self, client: Orb) -> None: + def test_streaming_response_create_overload_26(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -2890,7 +3013,7 @@ def test_streaming_response_create_overload_25(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_26(self, client: Orb) -> None: + def test_method_create_overload_27(self, client: Orb) -> None: price = client.prices.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -2911,7 +3034,7 @@ def test_method_create_overload_26(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_26(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_27(self, client: Orb) -> None: price = client.prices.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -2956,7 +3079,7 @@ def test_method_create_with_all_params_overload_26(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_26(self, client: Orb) -> None: + def test_raw_response_create_overload_27(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -2981,7 +3104,7 @@ def test_raw_response_create_overload_26(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_26(self, client: Orb) -> None: + def test_streaming_response_create_overload_27(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -3008,7 +3131,7 @@ def test_streaming_response_create_overload_26(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_27(self, client: Orb) -> None: + def test_method_create_overload_28(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3020,7 +3143,7 @@ def test_method_create_overload_27(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_27(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_28(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3059,7 +3182,7 @@ def test_method_create_with_all_params_overload_27(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_27(self, client: Orb) -> None: + def test_raw_response_create_overload_28(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -3075,7 +3198,7 @@ def test_raw_response_create_overload_27(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_27(self, client: Orb) -> None: + def test_streaming_response_create_overload_28(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -3093,7 +3216,7 @@ def test_streaming_response_create_overload_27(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_28(self, client: Orb) -> None: + def test_method_create_overload_29(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3105,7 +3228,7 @@ def test_method_create_overload_28(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_28(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_29(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3141,7 +3264,7 @@ def test_method_create_with_all_params_overload_28(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_28(self, client: Orb) -> None: + def test_raw_response_create_overload_29(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -3157,7 +3280,7 @@ def test_raw_response_create_overload_28(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_28(self, client: Orb) -> None: + def test_streaming_response_create_overload_29(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -3175,7 +3298,7 @@ def test_streaming_response_create_overload_28(self, client: Orb) -> None: assert cast(Any, response.is_closed) is True @parametrize - def test_method_create_overload_29(self, client: Orb) -> None: + def test_method_create_overload_30(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3187,7 +3310,7 @@ def test_method_create_overload_29(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_method_create_with_all_params_overload_29(self, client: Orb) -> None: + def test_method_create_with_all_params_overload_30(self, client: Orb) -> None: price = client.prices.create( cadence="annual", currency="currency", @@ -3226,7 +3349,7 @@ def test_method_create_with_all_params_overload_29(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_raw_response_create_overload_29(self, client: Orb) -> None: + def test_raw_response_create_overload_30(self, client: Orb) -> None: response = client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -3242,7 +3365,7 @@ def test_raw_response_create_overload_29(self, client: Orb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - def test_streaming_response_create_overload_29(self, client: Orb) -> None: + def test_streaming_response_create_overload_30(self, client: Orb) -> None: with client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -3792,16 +3915,105 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncOrb cadence="annual", currency="currency", item_id="item_id", - model_type="tiered", + model_type="tiered", + name="Annual fee", + tiered_config={ + "tiers": [ + { + "first_unit": 0, + "unit_amount": "unit_amount", + } + ] + }, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + price = await response.parse() + assert_matches_type(Price, price, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_create_overload_3(self, async_client: AsyncOrb) -> None: + price = await async_client.prices.create( + bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk", + name="Annual fee", + ) + assert_matches_type(Price, price, path=["response"]) + + @parametrize + async def test_method_create_with_all_params_overload_3(self, async_client: AsyncOrb) -> None: + price = await async_client.prices.create( + bulk_config={ + "tiers": [ + { + "unit_amount": "unit_amount", + "maximum_units": 0, + } + ] + }, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk", + name="Annual fee", + billable_metric_id="billable_metric_id", + billed_in_advance=True, + billing_cycle_configuration={ + "duration": 0, + "duration_unit": "day", + }, + conversion_rate=0, + conversion_rate_config={ + "conversion_rate_type": "unit", + "unit_config": {"unit_amount": "unit_amount"}, + }, + dimensional_price_configuration={ + "dimension_values": ["string"], + "dimensional_price_group_id": "dimensional_price_group_id", + "external_dimensional_price_group_id": "external_dimensional_price_group_id", + }, + external_price_id="external_price_id", + fixed_price_quantity=0, + invoice_grouping_key="x", + invoicing_cycle_configuration={ + "duration": 0, + "duration_unit": "day", + }, + metadata={"foo": "string"}, + ) + assert_matches_type(Price, price, path=["response"]) + + @parametrize + async def test_raw_response_create_overload_3(self, async_client: AsyncOrb) -> None: + response = await async_client.prices.with_raw_response.create( + bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk", + name="Annual fee", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + price = response.parse() + assert_matches_type(Price, price, path=["response"]) + + @parametrize + async def test_streaming_response_create_overload_3(self, async_client: AsyncOrb) -> None: + async with async_client.prices.with_streaming_response.create( + bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + cadence="annual", + currency="currency", + item_id="item_id", + model_type="bulk", name="Annual fee", - tiered_config={ - "tiers": [ - { - "first_unit": 0, - "unit_amount": "unit_amount", - } - ] - }, ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -3812,32 +4024,50 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_3(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_4(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( - bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, cadence="annual", currency="currency", item_id="item_id", - model_type="bulk", + model_type="bulk_with_filters", name="Annual fee", ) assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_3(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_4(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( - bulk_config={ + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], "tiers": [ { "unit_amount": "unit_amount", - "maximum_units": 0, - } - ] + "tier_lower_bound": "tier_lower_bound", + }, + { + "unit_amount": "unit_amount", + "tier_lower_bound": "tier_lower_bound", + }, + ], }, cadence="annual", currency="currency", item_id="item_id", - model_type="bulk", + model_type="bulk_with_filters", name="Annual fee", billable_metric_id="billable_metric_id", billed_in_advance=True, @@ -3867,13 +4097,21 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_3(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_4(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( - bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, cadence="annual", currency="currency", item_id="item_id", - model_type="bulk", + model_type="bulk_with_filters", name="Annual fee", ) @@ -3883,13 +4121,21 @@ async def test_raw_response_create_overload_3(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_3(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_4(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( - bulk_config={"tiers": [{"unit_amount": "unit_amount"}]}, + bulk_with_filters_config={ + "filters": [ + { + "property_key": "x", + "property_value": "x", + } + ], + "tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}], + }, cadence="annual", currency="currency", item_id="item_id", - model_type="bulk", + model_type="bulk_with_filters", name="Annual fee", ) as response: assert not response.is_closed @@ -3901,7 +4147,7 @@ async def test_streaming_response_create_overload_3(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_4(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_5(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -3916,7 +4162,7 @@ async def test_method_create_overload_4(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_4(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_5(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -3955,7 +4201,7 @@ async def test_method_create_with_all_params_overload_4(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_4(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_5(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -3974,7 +4220,7 @@ async def test_raw_response_create_overload_4(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_4(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_5(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -3995,7 +4241,7 @@ async def test_streaming_response_create_overload_4(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_5(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_6(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4016,7 +4262,7 @@ async def test_method_create_overload_5(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_5(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_6(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4061,7 +4307,7 @@ async def test_method_create_with_all_params_overload_5(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_5(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_6(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4086,7 +4332,7 @@ async def test_raw_response_create_overload_5(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_5(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_6(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4113,7 +4359,7 @@ async def test_streaming_response_create_overload_5(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_6(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_7(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4136,7 +4382,7 @@ async def test_method_create_overload_6(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_6(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_7(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4184,7 +4430,7 @@ async def test_method_create_with_all_params_overload_6(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_6(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_7(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4211,7 +4457,7 @@ async def test_raw_response_create_overload_6(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_6(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_7(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4240,7 +4486,7 @@ async def test_streaming_response_create_overload_6(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_7(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_8(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4264,7 +4510,7 @@ async def test_method_create_overload_7(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_7(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_8(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4312,7 +4558,7 @@ async def test_method_create_with_all_params_overload_7(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_7(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_8(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4340,7 +4586,7 @@ async def test_raw_response_create_overload_7(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_7(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_8(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4370,7 +4616,7 @@ async def test_streaming_response_create_overload_7(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_8(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_9(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4395,7 +4641,7 @@ async def test_method_create_overload_8(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_8(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_9(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4446,7 +4692,7 @@ async def test_method_create_with_all_params_overload_8(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_8(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_9(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4475,7 +4721,7 @@ async def test_raw_response_create_overload_8(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_8(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_9(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4506,7 +4752,7 @@ async def test_streaming_response_create_overload_8(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_9(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_10(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4530,7 +4776,7 @@ async def test_method_create_overload_9(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_9(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_10(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4578,7 +4824,7 @@ async def test_method_create_with_all_params_overload_9(self, async_client: Asyn assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_9(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_10(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4606,7 +4852,7 @@ async def test_raw_response_create_overload_9(self, async_client: AsyncOrb) -> N assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_9(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_10(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4636,7 +4882,7 @@ async def test_streaming_response_create_overload_9(self, async_client: AsyncOrb assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_10(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_11(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4662,7 +4908,7 @@ async def test_method_create_overload_10(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_10(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_11(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4712,7 +4958,7 @@ async def test_method_create_with_all_params_overload_10(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_10(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_11(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4742,7 +4988,7 @@ async def test_raw_response_create_overload_10(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_10(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_11(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4774,7 +5020,7 @@ async def test_streaming_response_create_overload_10(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_11(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_12(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4790,7 +5036,7 @@ async def test_method_create_overload_11(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_11(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_12(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4830,7 +5076,7 @@ async def test_method_create_with_all_params_overload_11(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_11(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_12(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4850,7 +5096,7 @@ async def test_raw_response_create_overload_11(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_11(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_12(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4872,7 +5118,7 @@ async def test_streaming_response_create_overload_11(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_12(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_13(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4887,7 +5133,7 @@ async def test_method_create_overload_12(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_12(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_13(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4926,7 +5172,7 @@ async def test_method_create_with_all_params_overload_12(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_12(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_13(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -4945,7 +5191,7 @@ async def test_raw_response_create_overload_12(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_12(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_13(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -4966,7 +5212,7 @@ async def test_streaming_response_create_overload_12(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_13(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_14(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -4988,7 +5234,7 @@ async def test_method_create_overload_13(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_13(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_14(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5034,7 +5280,7 @@ async def test_method_create_with_all_params_overload_13(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_13(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_14(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5060,7 +5306,7 @@ async def test_raw_response_create_overload_13(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_13(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_14(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5088,7 +5334,7 @@ async def test_streaming_response_create_overload_13(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_14(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_15(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5107,7 +5353,7 @@ async def test_method_create_overload_14(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_14(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_15(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5150,7 +5396,7 @@ async def test_method_create_with_all_params_overload_14(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_14(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_15(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5173,7 +5419,7 @@ async def test_raw_response_create_overload_14(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_14(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_15(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5198,7 +5444,7 @@ async def test_streaming_response_create_overload_14(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_15(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_16(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5210,7 +5456,7 @@ async def test_method_create_overload_15(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_15(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_16(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5246,7 +5492,7 @@ async def test_method_create_with_all_params_overload_15(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_15(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_16(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5262,7 +5508,7 @@ async def test_raw_response_create_overload_15(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_15(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_16(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5280,7 +5526,7 @@ async def test_streaming_response_create_overload_15(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_16(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_17(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5296,7 +5542,7 @@ async def test_method_create_overload_16(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_16(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_17(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5336,7 +5582,7 @@ async def test_method_create_with_all_params_overload_16(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_16(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_17(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5356,7 +5602,7 @@ async def test_raw_response_create_overload_16(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_16(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_17(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5378,7 +5624,7 @@ async def test_streaming_response_create_overload_16(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_17(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_18(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -5390,7 +5636,7 @@ async def test_method_create_overload_17(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_17(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_18(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( bulk_with_proration_config={ "tiers": [ @@ -5437,7 +5683,7 @@ async def test_method_create_with_all_params_overload_17(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_17(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_18(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -5453,7 +5699,7 @@ async def test_raw_response_create_overload_17(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_17(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_18(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( bulk_with_proration_config={"tiers": [{"unit_amount": "unit_amount"}, {"unit_amount": "unit_amount"}]}, cadence="annual", @@ -5471,7 +5717,7 @@ async def test_streaming_response_create_overload_17(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_18(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_19(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5487,7 +5733,7 @@ async def test_method_create_overload_18(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_18(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_19(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5527,7 +5773,7 @@ async def test_method_create_with_all_params_overload_18(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_18(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_19(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5547,7 +5793,7 @@ async def test_raw_response_create_overload_18(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_18(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_19(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5569,7 +5815,7 @@ async def test_streaming_response_create_overload_18(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_19(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_20(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5598,7 +5844,7 @@ async def test_method_create_overload_19(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_19(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_20(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5651,7 +5897,7 @@ async def test_method_create_with_all_params_overload_19(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_19(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_20(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5684,7 +5930,7 @@ async def test_raw_response_create_overload_19(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_19(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_20(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5719,7 +5965,7 @@ async def test_streaming_response_create_overload_19(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_20(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_21(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5736,7 +5982,7 @@ async def test_method_create_overload_20(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_20(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_21(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5777,7 +6023,7 @@ async def test_method_create_with_all_params_overload_20(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_20(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_21(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5798,7 +6044,7 @@ async def test_raw_response_create_overload_20(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_20(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_21(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5821,7 +6067,7 @@ async def test_streaming_response_create_overload_20(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_21(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_22(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5842,7 +6088,7 @@ async def test_method_create_overload_21(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_21(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_22(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5887,7 +6133,7 @@ async def test_method_create_with_all_params_overload_21(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_21(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_22(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -5912,7 +6158,7 @@ async def test_raw_response_create_overload_21(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_21(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_22(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -5939,7 +6185,7 @@ async def test_streaming_response_create_overload_21(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_22(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_23(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -5964,7 +6210,7 @@ async def test_method_create_overload_22(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_22(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_23(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6013,7 +6259,7 @@ async def test_method_create_with_all_params_overload_22(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_22(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_23(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6042,7 +6288,7 @@ async def test_raw_response_create_overload_22(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_22(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_23(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6073,7 +6319,7 @@ async def test_streaming_response_create_overload_22(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_23(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_24(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6098,7 +6344,7 @@ async def test_method_create_overload_23(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_23(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_24(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6147,7 +6393,7 @@ async def test_method_create_with_all_params_overload_23(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_23(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_24(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6176,7 +6422,7 @@ async def test_raw_response_create_overload_23(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_23(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_24(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6207,7 +6453,7 @@ async def test_streaming_response_create_overload_23(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_24(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_25(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6228,7 +6474,7 @@ async def test_method_create_overload_24(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_24(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_25(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6276,7 +6522,7 @@ async def test_method_create_with_all_params_overload_24(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_24(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_25(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6301,7 +6547,7 @@ async def test_raw_response_create_overload_24(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_24(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_25(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6328,7 +6574,7 @@ async def test_streaming_response_create_overload_24(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_25(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_26(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6358,7 +6604,7 @@ async def test_method_create_overload_25(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_25(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_26(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6414,7 +6660,7 @@ async def test_method_create_with_all_params_overload_25(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_25(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_26(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6448,7 +6694,7 @@ async def test_raw_response_create_overload_25(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_25(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_26(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6484,7 +6730,7 @@ async def test_streaming_response_create_overload_25(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_26(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_27(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -6505,7 +6751,7 @@ async def test_method_create_overload_26(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_26(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_27(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -6550,7 +6796,7 @@ async def test_method_create_with_all_params_overload_26(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_26(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_27(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -6575,7 +6821,7 @@ async def test_raw_response_create_overload_26(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_26(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_27(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", cumulative_grouped_bulk_config={ @@ -6602,7 +6848,7 @@ async def test_streaming_response_create_overload_26(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_27(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_28(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6614,7 +6860,7 @@ async def test_method_create_overload_27(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_27(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_28(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6653,7 +6899,7 @@ async def test_method_create_with_all_params_overload_27(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_27(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_28(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6669,7 +6915,7 @@ async def test_raw_response_create_overload_27(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_27(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_28(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6687,7 +6933,7 @@ async def test_streaming_response_create_overload_27(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_28(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_29(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6699,7 +6945,7 @@ async def test_method_create_overload_28(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_28(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_29(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6735,7 +6981,7 @@ async def test_method_create_with_all_params_overload_28(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_28(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_29(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6751,7 +6997,7 @@ async def test_raw_response_create_overload_28(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_28(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_29(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency", @@ -6769,7 +7015,7 @@ async def test_streaming_response_create_overload_28(self, async_client: AsyncOr assert cast(Any, response.is_closed) is True @parametrize - async def test_method_create_overload_29(self, async_client: AsyncOrb) -> None: + async def test_method_create_overload_30(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6781,7 +7027,7 @@ async def test_method_create_overload_29(self, async_client: AsyncOrb) -> None: assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_method_create_with_all_params_overload_29(self, async_client: AsyncOrb) -> None: + async def test_method_create_with_all_params_overload_30(self, async_client: AsyncOrb) -> None: price = await async_client.prices.create( cadence="annual", currency="currency", @@ -6820,7 +7066,7 @@ async def test_method_create_with_all_params_overload_29(self, async_client: Asy assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_raw_response_create_overload_29(self, async_client: AsyncOrb) -> None: + async def test_raw_response_create_overload_30(self, async_client: AsyncOrb) -> None: response = await async_client.prices.with_raw_response.create( cadence="annual", currency="currency", @@ -6836,7 +7082,7 @@ async def test_raw_response_create_overload_29(self, async_client: AsyncOrb) -> assert_matches_type(Price, price, path=["response"]) @parametrize - async def test_streaming_response_create_overload_29(self, async_client: AsyncOrb) -> None: + async def test_streaming_response_create_overload_30(self, async_client: AsyncOrb) -> None: async with async_client.prices.with_streaming_response.create( cadence="annual", currency="currency",