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

opencode/resources/plugin.py

@@ -6,10 +6,17 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
+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:
@@ -25,6 +32,16 @@ __all__ = ["PluginResource", "AsyncPluginResource"]
 class PluginResource(SyncAPIResource):
     """Operations under ``client.plugin`` (OpenCode ``plugin``)."""
 
+    @cached_property
+    def with_raw_response(self) -> PluginResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PluginResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PluginResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PluginResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -121,24 +138,57 @@ class PluginResource(SyncAPIResource):
 
         ``POST /api/plugin/update``
         """
-        self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/plugin/update",
-                query={"location": self._location(location)},
-                body={"targets": targets},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path="/api/plugin/update",
+                    query={"location": self._location(location)},
+                    body={"targets": targets},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class PluginResourceWithRawResponse:
+    """``client.plugin.with_raw_response``."""
+
+    def __init__(self, resource: PluginResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.check = to_raw_response_wrapper(resource.check)
+        self.update = to_raw_response_wrapper(resource.update)
+
+
+class PluginResourceWithStreamingResponse:
+    """``client.plugin.with_streaming_response``."""
+
+    def __init__(self, resource: PluginResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.check = to_streamed_response_wrapper(resource.check)
+        self.update = to_streamed_response_wrapper(resource.update)
+
+
 class AsyncPluginResource(AsyncAPIResource):
     """Operations under ``client.plugin`` (OpenCode ``plugin``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPluginResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPluginResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPluginResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPluginResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -235,16 +285,39 @@ class AsyncPluginResource(AsyncAPIResource):
 
         ``POST /api/plugin/update``
         """
-        await self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/plugin/update",
-                query={"location": self._location(location)},
-                body={"targets": targets},
-                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="/api/plugin/update",
+                    query={"location": self._location(location)},
+                    body={"targets": targets},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncPluginResourceWithRawResponse:
+    """``client.plugin.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPluginResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.check = async_to_raw_response_wrapper(resource.check)
+        self.update = async_to_raw_response_wrapper(resource.update)
+
+
+class AsyncPluginResourceWithStreamingResponse:
+    """``client.plugin.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPluginResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.check = async_to_streamed_response_wrapper(resource.check)
+        self.update = async_to_streamed_response_wrapper(resource.update)

opencode/resources/project.py

@@ -6,11 +6,18 @@
 from __future__ import annotations
 
 import builtins
+from functools import cached_property
 from typing import TYPE_CHECKING, 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:
@@ -28,6 +35,16 @@ __all__ = ["ProjectResource", "AsyncProjectResource"]
 class ProjectResource(SyncAPIResource):
     """Operations under ``client.project`` (OpenCode ``project``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ProjectResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ProjectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ProjectResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ProjectResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -106,9 +123,37 @@ class ProjectResource(SyncAPIResource):
         )
 
 
+class ProjectResourceWithRawResponse:
+    """``client.project.with_raw_response``."""
+
+    def __init__(self, resource: ProjectResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.update = to_raw_response_wrapper(resource.update)
+
+
+class ProjectResourceWithStreamingResponse:
+    """``client.project.with_streaming_response``."""
+
+    def __init__(self, resource: ProjectResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.update = to_streamed_response_wrapper(resource.update)
+
+
 class AsyncProjectResource(AsyncAPIResource):
     """Operations under ``client.project`` (OpenCode ``project``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncProjectResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncProjectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncProjectResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncProjectResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -185,3 +230,21 @@ class AsyncProjectResource(AsyncAPIResource):
                 response_type="Project",
             ),
         )
+
+
+class AsyncProjectResourceWithRawResponse:
+    """``client.project.with_raw_response``."""
+
+    def __init__(self, resource: AsyncProjectResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.update = async_to_raw_response_wrapper(resource.update)
+
+
+class AsyncProjectResourceWithStreamingResponse:
+    """``client.project.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncProjectResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.update = async_to_streamed_response_wrapper(resource.update)

opencode/resources/provider.py

@@ -5,11 +5,18 @@
 
 from __future__ import annotations
 
+from functools import cached_property
 from typing import TYPE_CHECKING, 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:
@@ -26,6 +33,16 @@ __all__ = ["ProviderResource", "AsyncProviderResource"]
 class ProviderResource(SyncAPIResource):
     """Operations under ``client.provider`` (OpenCode ``provider``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ProviderResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ProviderResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ProviderResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ProviderResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -103,9 +120,37 @@ class ProviderResource(SyncAPIResource):
         )
 
 
+class ProviderResourceWithRawResponse:
+    """``client.provider.with_raw_response``."""
+
+    def __init__(self, resource: ProviderResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.get = to_raw_response_wrapper(resource.get)
+
+
+class ProviderResourceWithStreamingResponse:
+    """``client.provider.with_streaming_response``."""
+
+    def __init__(self, resource: ProviderResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.get = to_streamed_response_wrapper(resource.get)
+
+
 class AsyncProviderResource(AsyncAPIResource):
     """Operations under ``client.provider`` (OpenCode ``provider``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncProviderResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncProviderResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncProviderResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncProviderResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -181,3 +226,21 @@ class AsyncProviderResource(AsyncAPIResource):
                 response_type="ProviderGetResponse",
             ),
         )
+
+
+class AsyncProviderResourceWithRawResponse:
+    """``client.provider.with_raw_response``."""
+
+    def __init__(self, resource: AsyncProviderResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.get = async_to_raw_response_wrapper(resource.get)
+
+
+class AsyncProviderResourceWithStreamingResponse:
+    """``client.provider.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncProviderResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.get = async_to_streamed_response_wrapper(resource.get)

opencode/resources/pty.py

@@ -13,6 +13,12 @@ from .._base_client import RequestOptions
 from .._pty import AsyncPtyAttachMixin, PtyAttachMixin
 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:
@@ -33,6 +39,16 @@ __all__ = ["PtyResource", "AsyncPtyResource"]
 class PtyConnectResource(SyncAPIResource):
     """Operations under ``client.pty.connect`` (OpenCode ``pty.connect``)."""
 
+    @cached_property
+    def with_raw_response(self) -> PtyConnectResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PtyConnectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PtyConnectResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PtyConnectResourceWithStreamingResponse(self)
+
     def token(
         self,
         pty_id: PtyID,
@@ -75,6 +91,22 @@ class PtyConnectResource(SyncAPIResource):
         )
 
 
+class PtyConnectResourceWithRawResponse:
+    """``client.pty.connect.with_raw_response``."""
+
+    def __init__(self, resource: PtyConnectResource) -> None:
+        self._resource = resource
+        self.token = to_raw_response_wrapper(resource.token)
+
+
+class PtyConnectResourceWithStreamingResponse:
+    """``client.pty.connect.with_streaming_response``."""
+
+    def __init__(self, resource: PtyConnectResource) -> None:
+        self._resource = resource
+        self.token = to_streamed_response_wrapper(resource.token)
+
+
 class PtyResource(PtyAttachMixin):
     """Operations under ``client.pty`` (OpenCode ``pty``)."""
 
@@ -83,6 +115,16 @@ class PtyResource(PtyAttachMixin):
         """Operations under ``client.pty.connect``."""
         return PtyConnectResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> PtyResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return PtyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PtyResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return PtyResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -262,23 +304,70 @@ class PtyResource(PtyAttachMixin):
 
         ``DELETE /api/pty/:ptyID``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/pty/{encode_path_segment(pty_id)}",
-                query={"location": self._location(location)},
-                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/pty/{encode_path_segment(pty_id)}",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class PtyResourceWithRawResponse:
+    """``client.pty.with_raw_response``."""
+
+    def __init__(self, resource: PtyResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.create = to_raw_response_wrapper(resource.create)
+        self.get = to_raw_response_wrapper(resource.get)
+        self.update = to_raw_response_wrapper(resource.update)
+        self.remove = to_raw_response_wrapper(resource.remove)
+
+    @cached_property
+    def connect(self) -> PtyConnectResourceWithRawResponse:
+        """``client.pty.connect.with_raw_response``."""
+        return PtyConnectResourceWithRawResponse(self._resource.connect)
+
+
+class PtyResourceWithStreamingResponse:
+    """``client.pty.with_streaming_response``."""
+
+    def __init__(self, resource: PtyResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.create = to_streamed_response_wrapper(resource.create)
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.update = to_streamed_response_wrapper(resource.update)
+        self.remove = to_streamed_response_wrapper(resource.remove)
+
+    @cached_property
+    def connect(self) -> PtyConnectResourceWithStreamingResponse:
+        """``client.pty.connect.with_streaming_response``."""
+        return PtyConnectResourceWithStreamingResponse(self._resource.connect)
+
+
 class AsyncPtyConnectResource(AsyncAPIResource):
     """Operations under ``client.pty.connect`` (OpenCode ``pty.connect``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPtyConnectResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPtyConnectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPtyConnectResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPtyConnectResourceWithStreamingResponse(self)
+
     async def token(
         self,
         pty_id: PtyID,
@@ -321,6 +410,22 @@ class AsyncPtyConnectResource(AsyncAPIResource):
         )
 
 
+class AsyncPtyConnectResourceWithRawResponse:
+    """``client.pty.connect.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPtyConnectResource) -> None:
+        self._resource = resource
+        self.token = async_to_raw_response_wrapper(resource.token)
+
+
+class AsyncPtyConnectResourceWithStreamingResponse:
+    """``client.pty.connect.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPtyConnectResource) -> None:
+        self._resource = resource
+        self.token = async_to_streamed_response_wrapper(resource.token)
+
+
 class AsyncPtyResource(AsyncPtyAttachMixin):
     """Operations under ``client.pty`` (OpenCode ``pty``)."""
 
@@ -329,6 +434,16 @@ class AsyncPtyResource(AsyncPtyAttachMixin):
         """Operations under ``client.pty.connect``."""
         return AsyncPtyConnectResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> AsyncPtyResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncPtyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPtyResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncPtyResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -508,15 +623,52 @@ class AsyncPtyResource(AsyncPtyAttachMixin):
 
         ``DELETE /api/pty/:ptyID``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/pty/{encode_path_segment(pty_id)}",
-                query={"location": self._location(location)},
-                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/pty/{encode_path_segment(pty_id)}",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncPtyResourceWithRawResponse:
+    """``client.pty.with_raw_response``."""
+
+    def __init__(self, resource: AsyncPtyResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.create = async_to_raw_response_wrapper(resource.create)
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.update = async_to_raw_response_wrapper(resource.update)
+        self.remove = async_to_raw_response_wrapper(resource.remove)
+
+    @cached_property
+    def connect(self) -> AsyncPtyConnectResourceWithRawResponse:
+        """``client.pty.connect.with_raw_response``."""
+        return AsyncPtyConnectResourceWithRawResponse(self._resource.connect)
+
+
+class AsyncPtyResourceWithStreamingResponse:
+    """``client.pty.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncPtyResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.create = async_to_streamed_response_wrapper(resource.create)
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.update = async_to_streamed_response_wrapper(resource.update)
+        self.remove = async_to_streamed_response_wrapper(resource.remove)
+
+    @cached_property
+    def connect(self) -> AsyncPtyConnectResourceWithStreamingResponse:
+        """``client.pty.connect.with_streaming_response``."""
+        return AsyncPtyConnectResourceWithStreamingResponse(self._resource.connect)

opencode/resources/reference.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:
@@ -23,6 +30,16 @@ __all__ = ["ReferenceResource", "AsyncReferenceResource"]
 class ReferenceResource(SyncAPIResource):
     """Operations under ``client.reference`` (OpenCode ``reference``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ReferenceResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ReferenceResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ReferenceResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ReferenceResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -60,9 +77,35 @@ class ReferenceResource(SyncAPIResource):
         )
 
 
+class ReferenceResourceWithRawResponse:
+    """``client.reference.with_raw_response``."""
+
+    def __init__(self, resource: ReferenceResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+
+
+class ReferenceResourceWithStreamingResponse:
+    """``client.reference.with_streaming_response``."""
+
+    def __init__(self, resource: ReferenceResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+
+
 class AsyncReferenceResource(AsyncAPIResource):
     """Operations under ``client.reference`` (OpenCode ``reference``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncReferenceResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncReferenceResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncReferenceResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncReferenceResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -98,3 +141,19 @@ class AsyncReferenceResource(AsyncAPIResource):
                 response_type="ReferenceListResponse",
             ),
         )
+
+
+class AsyncReferenceResourceWithRawResponse:
+    """``client.reference.with_raw_response``."""
+
+    def __init__(self, resource: AsyncReferenceResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+
+
+class AsyncReferenceResourceWithStreamingResponse:
+    """``client.reference.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncReferenceResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)