payi 0.1.0a26__py3-none-any.whl → 0.1.0a27__py3-none-any.whl

payi/_base_client.py

@@ -143,6 +143,12 @@ class PageInfo:
         self.url = url
         self.params = params
 
+    @override
+    def __repr__(self) -> str:
+        if self.url:
+            return f"{self.__class__.__name__}(url={self.url})"
+        return f"{self.__class__.__name__}(params={self.params})"
+
 
 class BasePage(GenericModel, Generic[_T]):
     """
@@ -689,7 +695,8 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         if retry_after is not None and 0 < retry_after <= 60:
             return retry_after
 
-        nb_retries = max_retries - remaining_retries
+        # Also cap retry count to 1000 to avoid any potential overflows with `pow`
+        nb_retries = min(max_retries - remaining_retries, 1000)
 
         # Apply exponential backoff, but not more than the max.
         sleep_seconds = min(INITIAL_RETRY_DELAY * pow(2.0, nb_retries), MAX_RETRY_DELAY)
@@ -1568,7 +1575,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         except Exception as err:
             log.debug("Encountered Exception", exc_info=True)
 
-            if retries_taken > 0:
+            if remaining_retries > 0:
                 return await self._retry_request(
                     input_options,
                     cast_to,

payi/_client.py

@@ -51,6 +51,8 @@ class Payi(SyncAPIClient):
     categories: resources.CategoriesResource
     experiences: resources.ExperiencesResource
     csat: resources.CsatResource
+    billing_models: resources.BillingModelsResource
+    price_modifiers: resources.PriceModifiersResource
     with_raw_response: PayiWithRawResponse
     with_streaming_response: PayiWithStreamedResponse
 
@@ -113,6 +115,8 @@ class Payi(SyncAPIClient):
         self.categories = resources.CategoriesResource(self)
         self.experiences = resources.ExperiencesResource(self)
         self.csat = resources.CsatResource(self)
+        self.billing_models = resources.BillingModelsResource(self)
+        self.price_modifiers = resources.PriceModifiersResource(self)
         self.with_raw_response = PayiWithRawResponse(self)
         self.with_streaming_response = PayiWithStreamedResponse(self)
 
@@ -227,6 +231,8 @@ class AsyncPayi(AsyncAPIClient):
     categories: resources.AsyncCategoriesResource
     experiences: resources.AsyncExperiencesResource
     csat: resources.AsyncCsatResource
+    billing_models: resources.AsyncBillingModelsResource
+    price_modifiers: resources.AsyncPriceModifiersResource
     with_raw_response: AsyncPayiWithRawResponse
     with_streaming_response: AsyncPayiWithStreamedResponse
 
@@ -289,6 +295,8 @@ class AsyncPayi(AsyncAPIClient):
         self.categories = resources.AsyncCategoriesResource(self)
         self.experiences = resources.AsyncExperiencesResource(self)
         self.csat = resources.AsyncCsatResource(self)
+        self.billing_models = resources.AsyncBillingModelsResource(self)
+        self.price_modifiers = resources.AsyncPriceModifiersResource(self)
         self.with_raw_response = AsyncPayiWithRawResponse(self)
         self.with_streaming_response = AsyncPayiWithStreamedResponse(self)
 
@@ -404,6 +412,8 @@ class PayiWithRawResponse:
         self.categories = resources.CategoriesResourceWithRawResponse(client.categories)
         self.experiences = resources.ExperiencesResourceWithRawResponse(client.experiences)
         self.csat = resources.CsatResourceWithRawResponse(client.csat)
+        self.billing_models = resources.BillingModelsResourceWithRawResponse(client.billing_models)
+        self.price_modifiers = resources.PriceModifiersResourceWithRawResponse(client.price_modifiers)
 
 
 class AsyncPayiWithRawResponse:
@@ -413,6 +423,8 @@ class AsyncPayiWithRawResponse:
         self.categories = resources.AsyncCategoriesResourceWithRawResponse(client.categories)
         self.experiences = resources.AsyncExperiencesResourceWithRawResponse(client.experiences)
         self.csat = resources.AsyncCsatResourceWithRawResponse(client.csat)
+        self.billing_models = resources.AsyncBillingModelsResourceWithRawResponse(client.billing_models)
+        self.price_modifiers = resources.AsyncPriceModifiersResourceWithRawResponse(client.price_modifiers)
 
 
 class PayiWithStreamedResponse:
@@ -422,6 +434,8 @@ class PayiWithStreamedResponse:
         self.categories = resources.CategoriesResourceWithStreamingResponse(client.categories)
         self.experiences = resources.ExperiencesResourceWithStreamingResponse(client.experiences)
         self.csat = resources.CsatResourceWithStreamingResponse(client.csat)
+        self.billing_models = resources.BillingModelsResourceWithStreamingResponse(client.billing_models)
+        self.price_modifiers = resources.PriceModifiersResourceWithStreamingResponse(client.price_modifiers)
 
 
 class AsyncPayiWithStreamedResponse:
@@ -431,6 +445,8 @@ class AsyncPayiWithStreamedResponse:
         self.categories = resources.AsyncCategoriesResourceWithStreamingResponse(client.categories)
         self.experiences = resources.AsyncExperiencesResourceWithStreamingResponse(client.experiences)
         self.csat = resources.AsyncCsatResourceWithStreamingResponse(client.csat)
+        self.billing_models = resources.AsyncBillingModelsResourceWithStreamingResponse(client.billing_models)
+        self.price_modifiers = resources.AsyncPriceModifiersResourceWithStreamingResponse(client.price_modifiers)
 
 
 Client = Payi

payi/_response.py

@@ -192,6 +192,9 @@ class BaseAPIResponse(Generic[R]):
         if cast_to == float:
             return cast(R, float(response.text))
 
+        if cast_to == bool:
+            return cast(R, response.text.lower() == "true")
+
         origin = get_origin(cast_to) or cast_to
 
         if origin == APIResponse:

payi/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "payi"
-__version__ = "0.1.0-alpha.26"  # x-release-please-version
+__version__ = "0.1.0-alpha.27"  # x-release-please-version

payi/resources/__init__.py

@@ -40,6 +40,22 @@ from .experiences import (
     ExperiencesResourceWithStreamingResponse,
     AsyncExperiencesResourceWithStreamingResponse,
 )
+from .billing_models import (
+    BillingModelsResource,
+    AsyncBillingModelsResource,
+    BillingModelsResourceWithRawResponse,
+    AsyncBillingModelsResourceWithRawResponse,
+    BillingModelsResourceWithStreamingResponse,
+    AsyncBillingModelsResourceWithStreamingResponse,
+)
+from .price_modifiers import (
+    PriceModifiersResource,
+    AsyncPriceModifiersResource,
+    PriceModifiersResourceWithRawResponse,
+    AsyncPriceModifiersResourceWithRawResponse,
+    PriceModifiersResourceWithStreamingResponse,
+    AsyncPriceModifiersResourceWithStreamingResponse,
+)
 
 __all__ = [
     "BudgetsResource",
@@ -72,4 +88,16 @@ __all__ = [
     "AsyncCsatResourceWithRawResponse",
     "CsatResourceWithStreamingResponse",
     "AsyncCsatResourceWithStreamingResponse",
+    "BillingModelsResource",
+    "AsyncBillingModelsResource",
+    "BillingModelsResourceWithRawResponse",
+    "AsyncBillingModelsResourceWithRawResponse",
+    "BillingModelsResourceWithStreamingResponse",
+    "AsyncBillingModelsResourceWithStreamingResponse",
+    "PriceModifiersResource",
+    "AsyncPriceModifiersResource",
+    "PriceModifiersResourceWithRawResponse",
+    "AsyncPriceModifiersResourceWithRawResponse",
+    "PriceModifiersResourceWithStreamingResponse",
+    "AsyncPriceModifiersResourceWithStreamingResponse",
 ]

payi/resources/billing_models.py

@@ -0,0 +1,492 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import billing_model_create_params, billing_model_update_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import (
+    maybe_transform,
+    async_maybe_transform,
+)
+from .._compat import cached_property
+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.billing_model import BillingModel
+from ..types.billing_model_list_response import BillingModelListResponse
+
+__all__ = ["BillingModelsResource", "AsyncBillingModelsResource"]
+
+
+class BillingModelsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BillingModelsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        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 BillingModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BillingModelsResourceWithStreamingResponse:
+        """
+        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 BillingModelsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        name: str,
+        type: Literal["costplus"],
+        prepaid_amount: Optional[float] | NotGiven = NOT_GIVEN,
+        prepaid_max: Optional[float] | NotGiven = NOT_GIVEN,
+        threshold: Optional[float] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        return self._post(
+            "/api/v1/billing-model",
+            body=maybe_transform(
+                {
+                    "name": name,
+                    "type": type,
+                    "prepaid_amount": prepaid_amount,
+                    "prepaid_max": prepaid_max,
+                    "threshold": threshold,
+                },
+                billing_model_create_params.BillingModelCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    def retrieve(
+        self,
+        billing_model_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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return self._get(
+            f"/api/v1/billing-model/{billing_model_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    def update(
+        self,
+        billing_model_id: str,
+        *,
+        type: Literal["costplus"],
+        name: Optional[str] | NotGiven = NOT_GIVEN,
+        prepaid_amount: Optional[float] | NotGiven = NOT_GIVEN,
+        prepaid_max: Optional[float] | NotGiven = NOT_GIVEN,
+        threshold: Optional[float] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return self._put(
+            f"/api/v1/billing-model/{billing_model_id}",
+            body=maybe_transform(
+                {
+                    "type": type,
+                    "name": name,
+                    "prepaid_amount": prepaid_amount,
+                    "prepaid_max": prepaid_max,
+                    "threshold": threshold,
+                },
+                billing_model_update_params.BillingModelUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    def list(
+        self,
+        *,
+        # 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,
+    ) -> BillingModelListResponse:
+        return self._get(
+            "/api/v1/billing-model",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModelListResponse,
+        )
+
+    def set_default(
+        self,
+        billing_model_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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return self._put(
+            f"/api/v1/billing-model/{billing_model_id}/default",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+
+class AsyncBillingModelsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBillingModelsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        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 AsyncBillingModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBillingModelsResourceWithStreamingResponse:
+        """
+        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 AsyncBillingModelsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        type: Literal["costplus"],
+        prepaid_amount: Optional[float] | NotGiven = NOT_GIVEN,
+        prepaid_max: Optional[float] | NotGiven = NOT_GIVEN,
+        threshold: Optional[float] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        return await self._post(
+            "/api/v1/billing-model",
+            body=await async_maybe_transform(
+                {
+                    "name": name,
+                    "type": type,
+                    "prepaid_amount": prepaid_amount,
+                    "prepaid_max": prepaid_max,
+                    "threshold": threshold,
+                },
+                billing_model_create_params.BillingModelCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    async def retrieve(
+        self,
+        billing_model_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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return await self._get(
+            f"/api/v1/billing-model/{billing_model_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    async def update(
+        self,
+        billing_model_id: str,
+        *,
+        type: Literal["costplus"],
+        name: Optional[str] | NotGiven = NOT_GIVEN,
+        prepaid_amount: Optional[float] | NotGiven = NOT_GIVEN,
+        prepaid_max: Optional[float] | NotGiven = NOT_GIVEN,
+        threshold: Optional[float] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return await self._put(
+            f"/api/v1/billing-model/{billing_model_id}",
+            body=await async_maybe_transform(
+                {
+                    "type": type,
+                    "name": name,
+                    "prepaid_amount": prepaid_amount,
+                    "prepaid_max": prepaid_max,
+                    "threshold": threshold,
+                },
+                billing_model_update_params.BillingModelUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+    async def list(
+        self,
+        *,
+        # 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,
+    ) -> BillingModelListResponse:
+        return await self._get(
+            "/api/v1/billing-model",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModelListResponse,
+        )
+
+    async def set_default(
+        self,
+        billing_model_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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BillingModel:
+        """
+        Args:
+          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
+        """
+        if not billing_model_id:
+            raise ValueError(f"Expected a non-empty value for `billing_model_id` but received {billing_model_id!r}")
+        return await self._put(
+            f"/api/v1/billing-model/{billing_model_id}/default",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BillingModel,
+        )
+
+
+class BillingModelsResourceWithRawResponse:
+    def __init__(self, billing_models: BillingModelsResource) -> None:
+        self._billing_models = billing_models
+
+        self.create = to_raw_response_wrapper(
+            billing_models.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            billing_models.retrieve,
+        )
+        self.update = to_raw_response_wrapper(
+            billing_models.update,
+        )
+        self.list = to_raw_response_wrapper(
+            billing_models.list,
+        )
+        self.set_default = to_raw_response_wrapper(
+            billing_models.set_default,
+        )
+
+
+class AsyncBillingModelsResourceWithRawResponse:
+    def __init__(self, billing_models: AsyncBillingModelsResource) -> None:
+        self._billing_models = billing_models
+
+        self.create = async_to_raw_response_wrapper(
+            billing_models.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            billing_models.retrieve,
+        )
+        self.update = async_to_raw_response_wrapper(
+            billing_models.update,
+        )
+        self.list = async_to_raw_response_wrapper(
+            billing_models.list,
+        )
+        self.set_default = async_to_raw_response_wrapper(
+            billing_models.set_default,
+        )
+
+
+class BillingModelsResourceWithStreamingResponse:
+    def __init__(self, billing_models: BillingModelsResource) -> None:
+        self._billing_models = billing_models
+
+        self.create = to_streamed_response_wrapper(
+            billing_models.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            billing_models.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            billing_models.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            billing_models.list,
+        )
+        self.set_default = to_streamed_response_wrapper(
+            billing_models.set_default,
+        )
+
+
+class AsyncBillingModelsResourceWithStreamingResponse:
+    def __init__(self, billing_models: AsyncBillingModelsResource) -> None:
+        self._billing_models = billing_models
+
+        self.create = async_to_streamed_response_wrapper(
+            billing_models.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            billing_models.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            billing_models.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            billing_models.list,
+        )
+        self.set_default = async_to_streamed_response_wrapper(
+            billing_models.set_default,
+        )