payi 0.1.0a13__py3-none-any.whl → 0.1.0a14__py3-none-any.whl

payi/_base_client.py

@@ -879,9 +879,9 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
     def _prepare_options(
         self,
         options: FinalRequestOptions,  # noqa: ARG002
-    ) -> None:
+    ) -> FinalRequestOptions:
         """Hook for mutating the given options"""
-        return None
+        return options
 
     def _prepare_request(
         self,
@@ -961,7 +961,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         input_options = model_copy(options)
 
         cast_to = self._maybe_override_cast_to(cast_to, options)
-        self._prepare_options(options)
+        options = self._prepare_options(options)
 
         retries = self._remaining_retries(remaining_retries, options)
         request = self._build_request(options)
@@ -1442,9 +1442,9 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
     async def _prepare_options(
         self,
         options: FinalRequestOptions,  # noqa: ARG002
-    ) -> None:
+    ) -> FinalRequestOptions:
         """Hook for mutating the given options"""
-        return None
+        return options
 
     async def _prepare_request(
         self,
@@ -1529,7 +1529,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         input_options = model_copy(options)
 
         cast_to = self._maybe_override_cast_to(cast_to, options)
-        await self._prepare_options(options)
+        options = await self._prepare_options(options)
 
         retries = self._remaining_retries(remaining_retries, options)
         request = self._build_request(options)

payi/_client.py

@@ -48,6 +48,7 @@ __all__ = [
 class Payi(SyncAPIClient):
     budgets: resources.BudgetsResource
     ingest: resources.IngestResource
+    categories: resources.CategoriesResource
     with_raw_response: PayiWithRawResponse
     with_streaming_response: PayiWithStreamedResponse
 
@@ -107,6 +108,7 @@ class Payi(SyncAPIClient):
 
         self.budgets = resources.BudgetsResource(self)
         self.ingest = resources.IngestResource(self)
+        self.categories = resources.CategoriesResource(self)
         self.with_raw_response = PayiWithRawResponse(self)
         self.with_streaming_response = PayiWithStreamedResponse(self)
 
@@ -218,6 +220,7 @@ class Payi(SyncAPIClient):
 class AsyncPayi(AsyncAPIClient):
     budgets: resources.AsyncBudgetsResource
     ingest: resources.AsyncIngestResource
+    categories: resources.AsyncCategoriesResource
     with_raw_response: AsyncPayiWithRawResponse
     with_streaming_response: AsyncPayiWithStreamedResponse
 
@@ -277,6 +280,7 @@ class AsyncPayi(AsyncAPIClient):
 
         self.budgets = resources.AsyncBudgetsResource(self)
         self.ingest = resources.AsyncIngestResource(self)
+        self.categories = resources.AsyncCategoriesResource(self)
         self.with_raw_response = AsyncPayiWithRawResponse(self)
         self.with_streaming_response = AsyncPayiWithStreamedResponse(self)
 
@@ -389,24 +393,28 @@ class PayiWithRawResponse:
     def __init__(self, client: Payi) -> None:
         self.budgets = resources.BudgetsResourceWithRawResponse(client.budgets)
         self.ingest = resources.IngestResourceWithRawResponse(client.ingest)
+        self.categories = resources.CategoriesResourceWithRawResponse(client.categories)
 
 
 class AsyncPayiWithRawResponse:
     def __init__(self, client: AsyncPayi) -> None:
         self.budgets = resources.AsyncBudgetsResourceWithRawResponse(client.budgets)
         self.ingest = resources.AsyncIngestResourceWithRawResponse(client.ingest)
+        self.categories = resources.AsyncCategoriesResourceWithRawResponse(client.categories)
 
 
 class PayiWithStreamedResponse:
     def __init__(self, client: Payi) -> None:
         self.budgets = resources.BudgetsResourceWithStreamingResponse(client.budgets)
         self.ingest = resources.IngestResourceWithStreamingResponse(client.ingest)
+        self.categories = resources.CategoriesResourceWithStreamingResponse(client.categories)
 
 
 class AsyncPayiWithStreamedResponse:
     def __init__(self, client: AsyncPayi) -> None:
         self.budgets = resources.AsyncBudgetsResourceWithStreamingResponse(client.budgets)
         self.ingest = resources.AsyncIngestResourceWithStreamingResponse(client.ingest)
+        self.categories = resources.AsyncCategoriesResourceWithStreamingResponse(client.categories)
 
 
 Client = Payi

payi/_compat.py

@@ -118,10 +118,10 @@ def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]:
     return model.__fields__  # type: ignore
 
 
-def model_copy(model: _ModelT) -> _ModelT:
+def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT:
     if PYDANTIC_V2:
-        return model.model_copy()
-    return model.copy()  # type: ignore
+        return model.model_copy(deep=deep)
+    return model.copy(deep=deep)  # type: ignore
 
 
 def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:

payi/_models.py

@@ -406,6 +406,15 @@ def build(
     return cast(_BaseModelT, construct_type(type_=base_model_cls, value=kwargs))
 
 
+def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T:
+    """Loose coercion to the expected type with construction of nested values.
+
+    Note: the returned value from this function is not guaranteed to match the
+    given type.
+    """
+    return cast(_T, construct_type(value=value, type_=type_))
+
+
 def construct_type(*, value: object, type_: object) -> object:
     """Loose coercion to the expected type with construction of nested values.
 

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.13"  # x-release-please-version
+__version__ = "0.1.0-alpha.14"  # x-release-please-version

payi/resources/__init__.py

@@ -16,6 +16,14 @@ from .budgets import (
     BudgetsResourceWithStreamingResponse,
     AsyncBudgetsResourceWithStreamingResponse,
 )
+from .categories import (
+    CategoriesResource,
+    AsyncCategoriesResource,
+    CategoriesResourceWithRawResponse,
+    AsyncCategoriesResourceWithRawResponse,
+    CategoriesResourceWithStreamingResponse,
+    AsyncCategoriesResourceWithStreamingResponse,
+)
 
 __all__ = [
     "BudgetsResource",
@@ -30,4 +38,10 @@ __all__ = [
     "AsyncIngestResourceWithRawResponse",
     "IngestResourceWithStreamingResponse",
     "AsyncIngestResourceWithStreamingResponse",
+    "CategoriesResource",
+    "AsyncCategoriesResource",
+    "CategoriesResourceWithRawResponse",
+    "AsyncCategoriesResourceWithRawResponse",
+    "CategoriesResourceWithStreamingResponse",
+    "AsyncCategoriesResourceWithStreamingResponse",
 ]

payi/resources/budgets/budgets.py

@@ -57,9 +57,11 @@ class BudgetsResource(SyncAPIResource):
         budget_name: str,
         max: float,
         base_cost_estimate: Literal["max"] | NotGiven = NOT_GIVEN,
+        billing_model_id: Optional[int] | NotGiven = NOT_GIVEN,
         budget_response_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
         budget_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
         budget_type: Literal["conservative", "liberal"] | NotGiven = NOT_GIVEN,
+        cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
         currency: Literal["usd"] | 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.
@@ -90,9 +92,11 @@ class BudgetsResource(SyncAPIResource):
                     "budget_name": budget_name,
                     "max": max,
                     "base_cost_estimate": base_cost_estimate,
+                    "billing_model_id": billing_model_id,
                     "budget_response_type": budget_response_type,
                     "budget_tags": budget_tags,
                     "budget_type": budget_type,
+                    "cost_basis": cost_basis,
                     "currency": currency,
                 },
                 budget_create_params.BudgetCreateParams,
@@ -138,8 +142,8 @@ class BudgetsResource(SyncAPIResource):
         self,
         budget_id: str,
         *,
-        budget_name: str,
-        max: float | NotGiven = NOT_GIVEN,
+        budget_name: Optional[str] | NotGiven = NOT_GIVEN,
+        max: 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,
@@ -305,9 +309,11 @@ class AsyncBudgetsResource(AsyncAPIResource):
         budget_name: str,
         max: float,
         base_cost_estimate: Literal["max"] | NotGiven = NOT_GIVEN,
+        billing_model_id: Optional[int] | NotGiven = NOT_GIVEN,
         budget_response_type: Literal["block", "allow"] | NotGiven = NOT_GIVEN,
         budget_tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
         budget_type: Literal["conservative", "liberal"] | NotGiven = NOT_GIVEN,
+        cost_basis: Literal["base", "billed"] | NotGiven = NOT_GIVEN,
         currency: Literal["usd"] | 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.
@@ -335,9 +341,11 @@ class AsyncBudgetsResource(AsyncAPIResource):
                     "budget_name": budget_name,
                     "max": max,
                     "base_cost_estimate": base_cost_estimate,
+                    "billing_model_id": billing_model_id,
                     "budget_response_type": budget_response_type,
                     "budget_tags": budget_tags,
                     "budget_type": budget_type,
+                    "cost_basis": cost_basis,
                     "currency": currency,
                 },
                 budget_create_params.BudgetCreateParams,
@@ -385,8 +393,8 @@ class AsyncBudgetsResource(AsyncAPIResource):
         self,
         budget_id: str,
         *,
-        budget_name: str,
-        max: float | NotGiven = NOT_GIVEN,
+        budget_name: Optional[str] | NotGiven = NOT_GIVEN,
+        max: 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,

payi/resources/categories/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .resources import (
+    ResourcesResource,
+    AsyncResourcesResource,
+    ResourcesResourceWithRawResponse,
+    AsyncResourcesResourceWithRawResponse,
+    ResourcesResourceWithStreamingResponse,
+    AsyncResourcesResourceWithStreamingResponse,
+)
+from .categories import (
+    CategoriesResource,
+    AsyncCategoriesResource,
+    CategoriesResourceWithRawResponse,
+    AsyncCategoriesResourceWithRawResponse,
+    CategoriesResourceWithStreamingResponse,
+    AsyncCategoriesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ResourcesResource",
+    "AsyncResourcesResource",
+    "ResourcesResourceWithRawResponse",
+    "AsyncResourcesResourceWithRawResponse",
+    "ResourcesResourceWithStreamingResponse",
+    "AsyncResourcesResourceWithStreamingResponse",
+    "CategoriesResource",
+    "AsyncCategoriesResource",
+    "CategoriesResourceWithRawResponse",
+    "AsyncCategoriesResourceWithRawResponse",
+    "CategoriesResourceWithStreamingResponse",
+    "AsyncCategoriesResourceWithStreamingResponse",
+]

payi/resources/categories/categories.py

@@ -0,0 +1,388 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._compat import cached_property
+from .resources import (
+    ResourcesResource,
+    AsyncResourcesResource,
+    ResourcesResourceWithRawResponse,
+    AsyncResourcesResourceWithRawResponse,
+    ResourcesResourceWithStreamingResponse,
+    AsyncResourcesResourceWithStreamingResponse,
+)
+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.category_list_response import CategoryListResponse
+from ...types.category_delete_response import CategoryDeleteResponse
+from ...types.category_list_resources_response import CategoryListResourcesResponse
+from ...types.category_delete_resource_response import CategoryDeleteResourceResponse
+
+__all__ = ["CategoriesResource", "AsyncCategoriesResource"]
+
+
+class CategoriesResource(SyncAPIResource):
+    @cached_property
+    def resources(self) -> ResourcesResource:
+        return ResourcesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> CategoriesResourceWithRawResponse:
+        return CategoriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CategoriesResourceWithStreamingResponse:
+        return CategoriesResourceWithStreamingResponse(self)
+
+    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,
+    ) -> CategoryListResponse:
+        """Get all Categories"""
+        return self._get(
+            "/api/v1/categories",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResponse,
+        )
+
+    def delete(
+        self,
+        category: 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,
+    ) -> CategoryDeleteResponse:
+        """
+        Delete a Category and all of its Resources
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        return self._delete(
+            f"/api/v1/categories/{category}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryDeleteResponse,
+        )
+
+    def delete_resource(
+        self,
+        resource: str,
+        *,
+        category: 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,
+    ) -> CategoryDeleteResourceResponse:
+        """
+        Delete all versions of Resource from a Category
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return self._delete(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryDeleteResourceResponse,
+        )
+
+    def list_resources(
+        self,
+        category: 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,
+    ) -> CategoryListResourcesResponse:
+        """
+        Get all Resources for a Category
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        return self._get(
+            f"/api/v1/categories/{category}/resources",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResourcesResponse,
+        )
+
+
+class AsyncCategoriesResource(AsyncAPIResource):
+    @cached_property
+    def resources(self) -> AsyncResourcesResource:
+        return AsyncResourcesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncCategoriesResourceWithRawResponse:
+        return AsyncCategoriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCategoriesResourceWithStreamingResponse:
+        return AsyncCategoriesResourceWithStreamingResponse(self)
+
+    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,
+    ) -> CategoryListResponse:
+        """Get all Categories"""
+        return await self._get(
+            "/api/v1/categories",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResponse,
+        )
+
+    async def delete(
+        self,
+        category: 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,
+    ) -> CategoryDeleteResponse:
+        """
+        Delete a Category and all of its Resources
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        return await self._delete(
+            f"/api/v1/categories/{category}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryDeleteResponse,
+        )
+
+    async def delete_resource(
+        self,
+        resource: str,
+        *,
+        category: 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,
+    ) -> CategoryDeleteResourceResponse:
+        """
+        Delete all versions of Resource from a Category
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return await self._delete(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryDeleteResourceResponse,
+        )
+
+    async def list_resources(
+        self,
+        category: 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,
+    ) -> CategoryListResourcesResponse:
+        """
+        Get all Resources for a Category
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        return await self._get(
+            f"/api/v1/categories/{category}/resources",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResourcesResponse,
+        )
+
+
+class CategoriesResourceWithRawResponse:
+    def __init__(self, categories: CategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = to_raw_response_wrapper(
+            categories.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            categories.delete,
+        )
+        self.delete_resource = to_raw_response_wrapper(
+            categories.delete_resource,
+        )
+        self.list_resources = to_raw_response_wrapper(
+            categories.list_resources,
+        )
+
+    @cached_property
+    def resources(self) -> ResourcesResourceWithRawResponse:
+        return ResourcesResourceWithRawResponse(self._categories.resources)
+
+
+class AsyncCategoriesResourceWithRawResponse:
+    def __init__(self, categories: AsyncCategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = async_to_raw_response_wrapper(
+            categories.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            categories.delete,
+        )
+        self.delete_resource = async_to_raw_response_wrapper(
+            categories.delete_resource,
+        )
+        self.list_resources = async_to_raw_response_wrapper(
+            categories.list_resources,
+        )
+
+    @cached_property
+    def resources(self) -> AsyncResourcesResourceWithRawResponse:
+        return AsyncResourcesResourceWithRawResponse(self._categories.resources)
+
+
+class CategoriesResourceWithStreamingResponse:
+    def __init__(self, categories: CategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = to_streamed_response_wrapper(
+            categories.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            categories.delete,
+        )
+        self.delete_resource = to_streamed_response_wrapper(
+            categories.delete_resource,
+        )
+        self.list_resources = to_streamed_response_wrapper(
+            categories.list_resources,
+        )
+
+    @cached_property
+    def resources(self) -> ResourcesResourceWithStreamingResponse:
+        return ResourcesResourceWithStreamingResponse(self._categories.resources)
+
+
+class AsyncCategoriesResourceWithStreamingResponse:
+    def __init__(self, categories: AsyncCategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = async_to_streamed_response_wrapper(
+            categories.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            categories.delete,
+        )
+        self.delete_resource = async_to_streamed_response_wrapper(
+            categories.delete_resource,
+        )
+        self.list_resources = async_to_streamed_response_wrapper(
+            categories.list_resources,
+        )
+
+    @cached_property
+    def resources(self) -> AsyncResourcesResourceWithStreamingResponse:
+        return AsyncResourcesResourceWithStreamingResponse(self._categories.resources)