opencode-python-sdk 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

opencode/resources/migration.py

@@ -10,6 +10,12 @@ from typing import TYPE_CHECKING, cast
 
 from .._base_client import RequestOptions
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
 if TYPE_CHECKING:
@@ -25,6 +31,16 @@ __all__ = ["MigrationResource", "AsyncMigrationResource"]
 class MigrationV1Resource(SyncAPIResource):
     """Operations under ``client.migration.v1`` (OpenCode ``migration.v1``)."""
 
+    @cached_property
+    def with_raw_response(self) -> MigrationV1ResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return MigrationV1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> MigrationV1ResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return MigrationV1ResourceWithStreamingResponse(self)
+
     def status(
         self,
         *,
@@ -61,6 +77,22 @@ class MigrationV1Resource(SyncAPIResource):
         )
 
 
+class MigrationV1ResourceWithRawResponse:
+    """``client.migration.v1.with_raw_response``."""
+
+    def __init__(self, resource: MigrationV1Resource) -> None:
+        self._resource = resource
+        self.status = to_raw_response_wrapper(resource.status)
+
+
+class MigrationV1ResourceWithStreamingResponse:
+    """``client.migration.v1.with_streaming_response``."""
+
+    def __init__(self, resource: MigrationV1Resource) -> None:
+        self._resource = resource
+        self.status = to_streamed_response_wrapper(resource.status)
+
+
 class MigrationResource(SyncAPIResource):
     """Operations under ``client.migration`` (OpenCode ``migration``)."""
 
@@ -69,10 +101,54 @@ class MigrationResource(SyncAPIResource):
         """Operations under ``client.migration.v1``."""
         return MigrationV1Resource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> MigrationResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return MigrationResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> MigrationResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return MigrationResourceWithStreamingResponse(self)
+
+
+class MigrationResourceWithRawResponse:
+    """``client.migration.with_raw_response``."""
+
+    def __init__(self, resource: MigrationResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def v1(self) -> MigrationV1ResourceWithRawResponse:
+        """``client.migration.v1.with_raw_response``."""
+        return MigrationV1ResourceWithRawResponse(self._resource.v1)
+
+
+class MigrationResourceWithStreamingResponse:
+    """``client.migration.with_streaming_response``."""
+
+    def __init__(self, resource: MigrationResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def v1(self) -> MigrationV1ResourceWithStreamingResponse:
+        """``client.migration.v1.with_streaming_response``."""
+        return MigrationV1ResourceWithStreamingResponse(self._resource.v1)
+
 
 class AsyncMigrationV1Resource(AsyncAPIResource):
     """Operations under ``client.migration.v1`` (OpenCode ``migration.v1``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncMigrationV1ResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncMigrationV1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncMigrationV1ResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncMigrationV1ResourceWithStreamingResponse(self)
+
     async def status(
         self,
         *,
@@ -109,6 +185,22 @@ class AsyncMigrationV1Resource(AsyncAPIResource):
         )
 
 
+class AsyncMigrationV1ResourceWithRawResponse:
+    """``client.migration.v1.with_raw_response``."""
+
+    def __init__(self, resource: AsyncMigrationV1Resource) -> None:
+        self._resource = resource
+        self.status = async_to_raw_response_wrapper(resource.status)
+
+
+class AsyncMigrationV1ResourceWithStreamingResponse:
+    """``client.migration.v1.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncMigrationV1Resource) -> None:
+        self._resource = resource
+        self.status = async_to_streamed_response_wrapper(resource.status)
+
+
 class AsyncMigrationResource(AsyncAPIResource):
     """Operations under ``client.migration`` (OpenCode ``migration``)."""
 
@@ -116,3 +208,37 @@ class AsyncMigrationResource(AsyncAPIResource):
     def v1(self) -> AsyncMigrationV1Resource:
         """Operations under ``client.migration.v1``."""
         return AsyncMigrationV1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncMigrationResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncMigrationResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncMigrationResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncMigrationResourceWithStreamingResponse(self)
+
+
+class AsyncMigrationResourceWithRawResponse:
+    """``client.migration.with_raw_response``."""
+
+    def __init__(self, resource: AsyncMigrationResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def v1(self) -> AsyncMigrationV1ResourceWithRawResponse:
+        """``client.migration.v1.with_raw_response``."""
+        return AsyncMigrationV1ResourceWithRawResponse(self._resource.v1)
+
+
+class AsyncMigrationResourceWithStreamingResponse:
+    """``client.migration.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncMigrationResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def v1(self) -> AsyncMigrationV1ResourceWithStreamingResponse:
+        """``client.migration.v1.with_streaming_response``."""
+        return AsyncMigrationV1ResourceWithStreamingResponse(self._resource.v1)

opencode/resources/model.py

@@ -5,10 +5,17 @@
 
 from __future__ import annotations
 
+from functools import cached_property
 from typing import TYPE_CHECKING, cast
 
 from .._base_client import RequestOptions
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
 if TYPE_CHECKING:
@@ -24,6 +31,16 @@ __all__ = ["ModelResource", "AsyncModelResource"]
 class ModelResource(SyncAPIResource):
     """Operations under ``client.model`` (OpenCode ``model``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ModelResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ModelResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ModelResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ModelResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -99,9 +116,37 @@ class ModelResource(SyncAPIResource):
         )
 
 
+class ModelResourceWithRawResponse:
+    """``client.model.with_raw_response``."""
+
+    def __init__(self, resource: ModelResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.default = to_raw_response_wrapper(resource.default)
+
+
+class ModelResourceWithStreamingResponse:
+    """``client.model.with_streaming_response``."""
+
+    def __init__(self, resource: ModelResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.default = to_streamed_response_wrapper(resource.default)
+
+
 class AsyncModelResource(AsyncAPIResource):
     """Operations under ``client.model`` (OpenCode ``model``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncModelResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncModelResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncModelResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncModelResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -175,3 +220,21 @@ class AsyncModelResource(AsyncAPIResource):
                 response_type="ModelDefaultResponse",
             ),
         )
+
+
+class AsyncModelResourceWithRawResponse:
+    """``client.model.with_raw_response``."""
+
+    def __init__(self, resource: AsyncModelResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.default = async_to_raw_response_wrapper(resource.default)
+
+
+class AsyncModelResourceWithStreamingResponse:
+    """``client.model.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncModelResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.default = async_to_streamed_response_wrapper(resource.default)

opencode/resources/permission.py

@@ -13,6 +13,12 @@ from typing import TYPE_CHECKING, Any, cast
 from .._base_client import RequestOptions
 from .._qs import encode_path_segment
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
 if TYPE_CHECKING:
@@ -37,6 +43,16 @@ __all__ = ["PermissionResource", "AsyncPermissionResource"]
 class PermissionRequestResource(SyncAPIResource):
     """Operations under ``client.permission.request`` (OpenCode ``permission.request``)."""
 
+    @cached_property
+    def with_raw_response(self) -> PermissionRequestResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PermissionRequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PermissionRequestResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PermissionRequestResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -74,9 +90,35 @@ class PermissionRequestResource(SyncAPIResource):
         )
 
 
+class PermissionRequestResourceWithRawResponse:
+    """``client.permission.request.with_raw_response``."""
+
+    def __init__(self, resource: PermissionRequestResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+
+
+class PermissionRequestResourceWithStreamingResponse:
+    """``client.permission.request.with_streaming_response``."""
+
+    def __init__(self, resource: PermissionRequestResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+
+
 class PermissionSavedResource(SyncAPIResource):
     """Operations under ``client.permission.saved`` (OpenCode ``permission.saved``)."""
 
+    @cached_property
+    def with_raw_response(self) -> PermissionSavedResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PermissionSavedResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PermissionSavedResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PermissionSavedResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -175,19 +217,42 @@ class PermissionSavedResource(SyncAPIResource):
 
         ``DELETE /api/permission/saved/:id``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/permission/saved/{encode_path_segment(id)}",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path=f"/api/permission/saved/{encode_path_segment(id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class PermissionSavedResourceWithRawResponse:
+    """``client.permission.saved.with_raw_response``."""
+
+    def __init__(self, resource: PermissionSavedResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.update = to_raw_response_wrapper(resource.update)
+        self.remove = to_raw_response_wrapper(resource.remove)
+
+
+class PermissionSavedResourceWithStreamingResponse:
+    """``client.permission.saved.with_streaming_response``."""
+
+    def __init__(self, resource: PermissionSavedResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.update = to_streamed_response_wrapper(resource.update)
+        self.remove = to_streamed_response_wrapper(resource.remove)
+
+
 class PermissionResource(SyncAPIResource):
     """Operations under ``client.permission`` (OpenCode ``permission``)."""
 
@@ -201,6 +266,16 @@ class PermissionResource(SyncAPIResource):
         """Operations under ``client.permission.saved``."""
         return PermissionSavedResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> PermissionResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PermissionResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PermissionResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PermissionResourceWithStreamingResponse(self)
+
     def create(
         self,
         session_id: SessionID,
@@ -355,23 +430,78 @@ class PermissionResource(SyncAPIResource):
 
         ``POST /api/session/:sessionID/permission/:requestID/reply``
         """
-        self._client.request(
-            RequestOptions(
-                method="POST",
-                path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply",
-                body={"decision": decision, "message": message},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply",
+                    body={"decision": decision, "message": message},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class PermissionResourceWithRawResponse:
+    """``client.permission.with_raw_response``."""
+
+    def __init__(self, resource: PermissionResource) -> None:
+        self._resource = resource
+        self.create = to_raw_response_wrapper(resource.create)
+        self.list = to_raw_response_wrapper(resource.list)
+        self.get = to_raw_response_wrapper(resource.get)
+        self.reply = to_raw_response_wrapper(resource.reply)
+
+    @cached_property
+    def request_(self) -> PermissionRequestResourceWithRawResponse:
+        """``client.permission.request.with_raw_response``."""
+        return PermissionRequestResourceWithRawResponse(self._resource.request_)
+
+    @cached_property
+    def saved(self) -> PermissionSavedResourceWithRawResponse:
+        """``client.permission.saved.with_raw_response``."""
+        return PermissionSavedResourceWithRawResponse(self._resource.saved)
+
+
+class PermissionResourceWithStreamingResponse:
+    """``client.permission.with_streaming_response``."""
+
+    def __init__(self, resource: PermissionResource) -> None:
+        self._resource = resource
+        self.create = to_streamed_response_wrapper(resource.create)
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.reply = to_streamed_response_wrapper(resource.reply)
+
+    @cached_property
+    def request_(self) -> PermissionRequestResourceWithStreamingResponse:
+        """``client.permission.request.with_streaming_response``."""
+        return PermissionRequestResourceWithStreamingResponse(self._resource.request_)
+
+    @cached_property
+    def saved(self) -> PermissionSavedResourceWithStreamingResponse:
+        """``client.permission.saved.with_streaming_response``."""
+        return PermissionSavedResourceWithStreamingResponse(self._resource.saved)
+
+
 class AsyncPermissionRequestResource(AsyncAPIResource):
     """Operations under ``client.permission.request`` (OpenCode ``permission.request``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPermissionRequestResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPermissionRequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPermissionRequestResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPermissionRequestResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -409,9 +539,35 @@ class AsyncPermissionRequestResource(AsyncAPIResource):
         )
 
 
+class AsyncPermissionRequestResourceWithRawResponse:
+    """``client.permission.request.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPermissionRequestResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+
+
+class AsyncPermissionRequestResourceWithStreamingResponse:
+    """``client.permission.request.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPermissionRequestResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+
+
 class AsyncPermissionSavedResource(AsyncAPIResource):
     """Operations under ``client.permission.saved`` (OpenCode ``permission.saved``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPermissionSavedResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPermissionSavedResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPermissionSavedResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPermissionSavedResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -510,19 +666,42 @@ class AsyncPermissionSavedResource(AsyncAPIResource):
 
         ``DELETE /api/permission/saved/:id``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/permission/saved/{encode_path_segment(id)}",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path=f"/api/permission/saved/{encode_path_segment(id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class AsyncPermissionSavedResourceWithRawResponse:
+    """``client.permission.saved.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPermissionSavedResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.update = async_to_raw_response_wrapper(resource.update)
+        self.remove = async_to_raw_response_wrapper(resource.remove)
+
+
+class AsyncPermissionSavedResourceWithStreamingResponse:
+    """``client.permission.saved.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPermissionSavedResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.update = async_to_streamed_response_wrapper(resource.update)
+        self.remove = async_to_streamed_response_wrapper(resource.remove)
+
+
 class AsyncPermissionResource(AsyncAPIResource):
     """Operations under ``client.permission`` (OpenCode ``permission``)."""
 
@@ -536,6 +715,16 @@ class AsyncPermissionResource(AsyncAPIResource):
         """Operations under ``client.permission.saved``."""
         return AsyncPermissionSavedResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPermissionResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPermissionResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPermissionResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPermissionResourceWithStreamingResponse(self)
+
     async def create(
         self,
         session_id: SessionID,
@@ -690,15 +879,60 @@ class AsyncPermissionResource(AsyncAPIResource):
 
         ``POST /api/session/:sessionID/permission/:requestID/reply``
         """
-        await self._client.request(
-            RequestOptions(
-                method="POST",
-                path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply",
-                body={"decision": decision, "message": message},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply",
+                    body={"decision": decision, "message": message},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncPermissionResourceWithRawResponse:
+    """``client.permission.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPermissionResource) -> None:
+        self._resource = resource
+        self.create = async_to_raw_response_wrapper(resource.create)
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.reply = async_to_raw_response_wrapper(resource.reply)
+
+    @cached_property
+    def request_(self) -> AsyncPermissionRequestResourceWithRawResponse:
+        """``client.permission.request.with_raw_response``."""
+        return AsyncPermissionRequestResourceWithRawResponse(self._resource.request_)
+
+    @cached_property
+    def saved(self) -> AsyncPermissionSavedResourceWithRawResponse:
+        """``client.permission.saved.with_raw_response``."""
+        return AsyncPermissionSavedResourceWithRawResponse(self._resource.saved)
+
+
+class AsyncPermissionResourceWithStreamingResponse:
+    """``client.permission.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPermissionResource) -> None:
+        self._resource = resource
+        self.create = async_to_streamed_response_wrapper(resource.create)
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.reply = async_to_streamed_response_wrapper(resource.reply)
+
+    @cached_property
+    def request_(self) -> AsyncPermissionRequestResourceWithStreamingResponse:
+        """``client.permission.request.with_streaming_response``."""
+        return AsyncPermissionRequestResourceWithStreamingResponse(self._resource.request_)
+
+    @cached_property
+    def saved(self) -> AsyncPermissionSavedResourceWithStreamingResponse:
+        """``client.permission.saved.with_streaming_response``."""
+        return AsyncPermissionSavedResourceWithStreamingResponse(self._resource.saved)