payi 0.1.0a55__py3-none-any.whl → 0.1.0a56__py3-none-any.whl

payi/resources/{price_modifiers.py → use_cases/use_cases.py}

@@ -4,62 +4,79 @@ from __future__ import annotations
 
 import httpx
 
-from ..types import price_modifier_create_params, price_modifier_update_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    maybe_transform,
-    async_maybe_transform,
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._compat import cached_property
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
 )
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
     to_raw_response_wrapper,
     to_streamed_response_wrapper,
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .._base_client import make_request_options
-from ..types.price_modifier import PriceModifier
-from ..types.price_modifier_retrieve_response import PriceModifierRetrieveResponse
+from .types.types import (
+    TypesResource,
+    AsyncTypesResource,
+    TypesResourceWithRawResponse,
+    AsyncTypesResourceWithRawResponse,
+    TypesResourceWithStreamingResponse,
+    AsyncTypesResourceWithStreamingResponse,
+)
+from ..._base_client import make_request_options
+from ...types.use_case_instance_response import UseCaseInstanceResponse
+
+__all__ = ["UseCasesResource", "AsyncUseCasesResource"]
 
-__all__ = ["PriceModifiersResource", "AsyncPriceModifiersResource"]
 
+class UseCasesResource(SyncAPIResource):
+    @cached_property
+    def types(self) -> TypesResource:
+        return TypesResource(self._client)
+
+    @cached_property
+    def properties(self) -> PropertiesResource:
+        return PropertiesResource(self._client)
 
-class PriceModifiersResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> PriceModifiersResourceWithRawResponse:
+    def with_raw_response(self) -> UseCasesResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
         """
-        return PriceModifiersResourceWithRawResponse(self)
+        return UseCasesResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> PriceModifiersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> UseCasesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
         """
-        return PriceModifiersResourceWithStreamingResponse(self)
+        return UseCasesResourceWithStreamingResponse(self)
 
     def create(
         self,
+        use_case_name: str,
         *,
-        billing_model_id: str,
-        category: str,
-        price_modifier: float,
-        resource: str,
         # 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,
-    ) -> PriceModifier:
+    ) -> UseCaseInstanceResponse:
         """
+        Create a Use Case instance
+
         Args:
           extra_headers: Send extra headers
 
@@ -69,26 +86,19 @@ class PriceModifiersResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        if not use_case_name:
+            raise ValueError(f"Expected a non-empty value for `use_case_name` but received {use_case_name!r}")
         return self._post(
-            "/api/v1/price-modifier",
-            body=maybe_transform(
-                {
-                    "billing_model_id": billing_model_id,
-                    "category": category,
-                    "price_modifier": price_modifier,
-                    "resource": resource,
-                },
-                price_modifier_create_params.PriceModifierCreateParams,
-            ),
+            f"/api/v1/use_cases/instances/{use_case_name}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifier,
+            cast_to=UseCaseInstanceResponse,
         )
 
     def retrieve(
         self,
-        billing_model_id: str,
+        use_case_id: str,
         *,
         # 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.
@@ -96,8 +106,10 @@ class PriceModifiersResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> PriceModifierRetrieveResponse:
+    ) -> UseCaseInstanceResponse:
         """
+        Get a Use Case instance details
+
         Args:
           extra_headers: Send extra headers
 
@@ -107,31 +119,30 @@ class PriceModifiersResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not billing_model_id:
-            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        if not use_case_id:
+            raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
         return self._get(
-            f"/api/v1/price-modifier/{billing_model_id}",
+            f"/api/v1/use_cases/instances/{use_case_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifierRetrieveResponse,
+            cast_to=UseCaseInstanceResponse,
         )
 
-    def update(
+    def delete(
         self,
+        use_case_id: str,
         *,
-        billing_model_id: str,
-        category: str,
-        price_modifier: float,
-        resource: str,
         # 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,
-    ) -> PriceModifier:
+    ) -> UseCaseInstanceResponse:
         """
+        Delete a Use Case instance
+
         Args:
           extra_headers: Send extra headers
 
@@ -141,59 +152,59 @@ class PriceModifiersResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._put(
-            "/api/v1/price-modifier",
-            body=maybe_transform(
-                {
-                    "billing_model_id": billing_model_id,
-                    "category": category,
-                    "price_modifier": price_modifier,
-                    "resource": resource,
-                },
-                price_modifier_update_params.PriceModifierUpdateParams,
-            ),
+        if not use_case_id:
+            raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
+        return self._delete(
+            f"/api/v1/use_cases/instances/{use_case_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifier,
+            cast_to=UseCaseInstanceResponse,
         )
 
 
-class AsyncPriceModifiersResource(AsyncAPIResource):
+class AsyncUseCasesResource(AsyncAPIResource):
+    @cached_property
+    def types(self) -> AsyncTypesResource:
+        return AsyncTypesResource(self._client)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResource:
+        return AsyncPropertiesResource(self._client)
+
     @cached_property
-    def with_raw_response(self) -> AsyncPriceModifiersResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncUseCasesResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncPriceModifiersResourceWithRawResponse(self)
+        return AsyncUseCasesResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncPriceModifiersResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncUseCasesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
         """
-        return AsyncPriceModifiersResourceWithStreamingResponse(self)
+        return AsyncUseCasesResourceWithStreamingResponse(self)
 
     async def create(
         self,
+        use_case_name: str,
         *,
-        billing_model_id: str,
-        category: str,
-        price_modifier: float,
-        resource: str,
         # 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,
-    ) -> PriceModifier:
+    ) -> UseCaseInstanceResponse:
         """
+        Create a Use Case instance
+
         Args:
           extra_headers: Send extra headers
 
@@ -203,26 +214,19 @@ class AsyncPriceModifiersResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        if not use_case_name:
+            raise ValueError(f"Expected a non-empty value for `use_case_name` but received {use_case_name!r}")
         return await self._post(
-            "/api/v1/price-modifier",
-            body=await async_maybe_transform(
-                {
-                    "billing_model_id": billing_model_id,
-                    "category": category,
-                    "price_modifier": price_modifier,
-                    "resource": resource,
-                },
-                price_modifier_create_params.PriceModifierCreateParams,
-            ),
+            f"/api/v1/use_cases/instances/{use_case_name}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifier,
+            cast_to=UseCaseInstanceResponse,
         )
 
     async def retrieve(
         self,
-        billing_model_id: str,
+        use_case_id: str,
         *,
         # 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.
@@ -230,8 +234,10 @@ class AsyncPriceModifiersResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> PriceModifierRetrieveResponse:
+    ) -> UseCaseInstanceResponse:
         """
+        Get a Use Case instance details
+
         Args:
           extra_headers: Send extra headers
 
@@ -241,31 +247,30 @@ class AsyncPriceModifiersResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not billing_model_id:
-            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        if not use_case_id:
+            raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
         return await self._get(
-            f"/api/v1/price-modifier/{billing_model_id}",
+            f"/api/v1/use_cases/instances/{use_case_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifierRetrieveResponse,
+            cast_to=UseCaseInstanceResponse,
         )
 
-    async def update(
+    async def delete(
         self,
+        use_case_id: str,
         *,
-        billing_model_id: str,
-        category: str,
-        price_modifier: float,
-        resource: str,
         # 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,
-    ) -> PriceModifier:
+    ) -> UseCaseInstanceResponse:
         """
+        Delete a Use Case instance
+
         Args:
           extra_headers: Send extra headers
 
@@ -275,79 +280,104 @@ class AsyncPriceModifiersResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return await self._put(
-            "/api/v1/price-modifier",
-            body=await async_maybe_transform(
-                {
-                    "billing_model_id": billing_model_id,
-                    "category": category,
-                    "price_modifier": price_modifier,
-                    "resource": resource,
-                },
-                price_modifier_update_params.PriceModifierUpdateParams,
-            ),
+        if not use_case_id:
+            raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
+        return await self._delete(
+            f"/api/v1/use_cases/instances/{use_case_id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=PriceModifier,
+            cast_to=UseCaseInstanceResponse,
         )
 
 
-class PriceModifiersResourceWithRawResponse:
-    def __init__(self, price_modifiers: PriceModifiersResource) -> None:
-        self._price_modifiers = price_modifiers
+class UseCasesResourceWithRawResponse:
+    def __init__(self, use_cases: UseCasesResource) -> None:
+        self._use_cases = use_cases
 
         self.create = to_raw_response_wrapper(
-            price_modifiers.create,
+            use_cases.create,
         )
         self.retrieve = to_raw_response_wrapper(
-            price_modifiers.retrieve,
+            use_cases.retrieve,
         )
-        self.update = to_raw_response_wrapper(
-            price_modifiers.update,
+        self.delete = to_raw_response_wrapper(
+            use_cases.delete,
         )
 
+    @cached_property
+    def types(self) -> TypesResourceWithRawResponse:
+        return TypesResourceWithRawResponse(self._use_cases.types)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithRawResponse:
+        return PropertiesResourceWithRawResponse(self._use_cases.properties)
+
 
-class AsyncPriceModifiersResourceWithRawResponse:
-    def __init__(self, price_modifiers: AsyncPriceModifiersResource) -> None:
-        self._price_modifiers = price_modifiers
+class AsyncUseCasesResourceWithRawResponse:
+    def __init__(self, use_cases: AsyncUseCasesResource) -> None:
+        self._use_cases = use_cases
 
         self.create = async_to_raw_response_wrapper(
-            price_modifiers.create,
+            use_cases.create,
         )
         self.retrieve = async_to_raw_response_wrapper(
-            price_modifiers.retrieve,
+            use_cases.retrieve,
         )
-        self.update = async_to_raw_response_wrapper(
-            price_modifiers.update,
+        self.delete = async_to_raw_response_wrapper(
+            use_cases.delete,
         )
 
+    @cached_property
+    def types(self) -> AsyncTypesResourceWithRawResponse:
+        return AsyncTypesResourceWithRawResponse(self._use_cases.types)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithRawResponse:
+        return AsyncPropertiesResourceWithRawResponse(self._use_cases.properties)
+
 
-class PriceModifiersResourceWithStreamingResponse:
-    def __init__(self, price_modifiers: PriceModifiersResource) -> None:
-        self._price_modifiers = price_modifiers
+class UseCasesResourceWithStreamingResponse:
+    def __init__(self, use_cases: UseCasesResource) -> None:
+        self._use_cases = use_cases
 
         self.create = to_streamed_response_wrapper(
-            price_modifiers.create,
+            use_cases.create,
         )
         self.retrieve = to_streamed_response_wrapper(
-            price_modifiers.retrieve,
+            use_cases.retrieve,
         )
-        self.update = to_streamed_response_wrapper(
-            price_modifiers.update,
+        self.delete = to_streamed_response_wrapper(
+            use_cases.delete,
         )
 
+    @cached_property
+    def types(self) -> TypesResourceWithStreamingResponse:
+        return TypesResourceWithStreamingResponse(self._use_cases.types)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithStreamingResponse:
+        return PropertiesResourceWithStreamingResponse(self._use_cases.properties)
+
 
-class AsyncPriceModifiersResourceWithStreamingResponse:
-    def __init__(self, price_modifiers: AsyncPriceModifiersResource) -> None:
-        self._price_modifiers = price_modifiers
+class AsyncUseCasesResourceWithStreamingResponse:
+    def __init__(self, use_cases: AsyncUseCasesResource) -> None:
+        self._use_cases = use_cases
 
         self.create = async_to_streamed_response_wrapper(
-            price_modifiers.create,
+            use_cases.create,
         )
         self.retrieve = async_to_streamed_response_wrapper(
-            price_modifiers.retrieve,
+            use_cases.retrieve,
         )
-        self.update = async_to_streamed_response_wrapper(
-            price_modifiers.update,
+        self.delete = async_to_streamed_response_wrapper(
+            use_cases.delete,
         )
+
+    @cached_property
+    def types(self) -> AsyncTypesResourceWithStreamingResponse:
+        return AsyncTypesResourceWithStreamingResponse(self._use_cases.types)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        return AsyncPropertiesResourceWithStreamingResponse(self._use_cases.properties)

payi/types/__init__.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from .shared import PayICommonModelsBudgetManagementCostDetailsBase as PayICommonModelsBudgetManagementCostDetailsBase
+from .shared import (
+    PropertiesResponse as PropertiesResponse,
+    PayICommonModelsBudgetManagementCostDetailsBase as PayICommonModelsBudgetManagementCostDetailsBase,
+    PayICommonModelsBudgetManagementCreateLimitBase as PayICommonModelsBudgetManagementCreateLimitBase,
+)
 from .cost_data import CostData as CostData
 from .cost_details import CostDetails as CostDetails
-from .billing_model import BillingModel as BillingModel
 from .requests_data import RequestsData as RequestsData
 from .limit_response import LimitResponse as LimitResponse
-from .price_modifier import PriceModifier as PriceModifier
 from .ingest_response import IngestResponse as IngestResponse
 from .total_cost_data import TotalCostData as TotalCostData
 from .default_response import DefaultResponse as DefaultResponse
@@ -26,14 +28,9 @@ from .category_list_response import CategoryListResponse as CategoryListResponse
 from .limit_history_response import LimitHistoryResponse as LimitHistoryResponse
 from .category_delete_response import CategoryDeleteResponse as CategoryDeleteResponse
 from .category_resource_response import CategoryResourceResponse as CategoryResourceResponse
-from .billing_model_create_params import BillingModelCreateParams as BillingModelCreateParams
-from .billing_model_list_response import BillingModelListResponse as BillingModelListResponse
-from .billing_model_update_params import BillingModelUpdateParams as BillingModelUpdateParams
+from .use_case_instance_response import UseCaseInstanceResponse as UseCaseInstanceResponse
 from .experience_instance_response import ExperienceInstanceResponse as ExperienceInstanceResponse
-from .price_modifier_create_params import PriceModifierCreateParams as PriceModifierCreateParams
-from .price_modifier_update_params import PriceModifierUpdateParams as PriceModifierUpdateParams
 from .category_list_resources_response import CategoryListResourcesResponse as CategoryListResourcesResponse
-from .price_modifier_retrieve_response import PriceModifierRetrieveResponse as PriceModifierRetrieveResponse
 from .category_delete_resource_response import CategoryDeleteResourceResponse as CategoryDeleteResourceResponse
 from .pay_i_common_models_api_router_header_info_param import (
     PayICommonModelsAPIRouterHeaderInfoParam as PayICommonModelsAPIRouterHeaderInfoParam,

payi/types/categories/resource_create_params.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 from datetime import datetime
 from typing_extensions import Required, Annotated, TypedDict
 
@@ -16,16 +16,16 @@ class ResourceCreateParams(TypedDict, total=False):
 
     units: Required[Dict[str, Units]]
 
-    max_input_units: int
+    max_input_units: Optional[int]
 
-    max_output_units: int
+    max_output_units: Optional[int]
 
-    max_total_units: int
+    max_total_units: Optional[int]
 
     start_timestamp: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
 
 
 class Units(TypedDict, total=False):
-    input_price: Required[float]
+    input_price: float
 
-    output_price: Required[float]
+    output_price: float

payi/types/category_resource_response.py

@@ -9,9 +9,9 @@ __all__ = ["CategoryResourceResponse", "Units"]
 
 
 class Units(BaseModel):
-    input_price: float
+    input_price: Optional[float] = None
 
-    output_price: float
+    output_price: Optional[float] = None
 
 
 class CategoryResourceResponse(BaseModel):

payi/types/experience_instance_response.py

@@ -11,3 +11,5 @@ class ExperienceInstanceResponse(BaseModel):
     experience_id: str
 
     limit_id: Optional[str] = None
+
+    type_version: Optional[int] = None

payi/types/experiences/__init__.py

@@ -7,5 +7,4 @@ from .type_list_params import TypeListParams as TypeListParams
 from .type_create_params import TypeCreateParams as TypeCreateParams
 from .type_list_response import TypeListResponse as TypeListResponse
 from .type_update_params import TypeUpdateParams as TypeUpdateParams
-from .properties_response import PropertiesResponse as PropertiesResponse
 from .property_create_params import PropertyCreateParams as PropertyCreateParams

payi/types/experiences/experience_type.py

@@ -1,21 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Optional
-from typing_extensions import Literal
+from typing import Optional
 
 from ..._models import BaseModel
+from ..shared.pay_i_common_models_budget_management_create_limit_base import (
+    PayICommonModelsBudgetManagementCreateLimitBase,
+)
 
-__all__ = ["ExperienceType", "LimitConfig"]
-
-
-class LimitConfig(BaseModel):
-    max: float
-
-    limit_tags: Optional[List[str]] = None
-
-    limit_type: Optional[Literal["block", "allow"]] = None
-
-    threshold: Optional[float] = None
+__all__ = ["ExperienceType"]
 
 
 class ExperienceType(BaseModel):
@@ -25,6 +17,8 @@ class ExperienceType(BaseModel):
 
     request_id: str
 
-    limit_config: Optional[LimitConfig] = None
+    limit_config: Optional[PayICommonModelsBudgetManagementCreateLimitBase] = None
 
     logging_enabled: Optional[bool] = None
+
+    type_version: Optional[int] = None

payi/types/experiences/type_create_params.py

@@ -2,10 +2,14 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
-from typing_extensions import Literal, Required, TypedDict
+from typing import Optional
+from typing_extensions import Required, TypedDict
 
-__all__ = ["TypeCreateParams", "LimitConfig"]
+from ..shared_params.pay_i_common_models_budget_management_create_limit_base import (
+    PayICommonModelsBudgetManagementCreateLimitBase,
+)
+
+__all__ = ["TypeCreateParams"]
 
 
 class TypeCreateParams(TypedDict, total=False):
@@ -13,16 +17,6 @@ class TypeCreateParams(TypedDict, total=False):
 
     name: Required[str]
 
-    limit_config: LimitConfig
+    limit_config: PayICommonModelsBudgetManagementCreateLimitBase
 
     logging_enabled: Optional[bool]
-
-
-class LimitConfig(TypedDict, total=False):
-    max: Required[float]
-
-    limit_tags: Optional[List[str]]
-
-    limit_type: Literal["block", "allow"]
-
-    threshold: Optional[float]