payi 0.1.0a104__py3-none-any.whl → 0.1.0a105__py3-none-any.whl

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

payi/resources/requests/__init__.py

@@ -1,13 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from .result import (
-    ResultResource,
-    AsyncResultResource,
-    ResultResourceWithRawResponse,
-    AsyncResultResourceWithRawResponse,
-    ResultResourceWithStreamingResponse,
-    AsyncResultResourceWithStreamingResponse,
-)
 from .requests import (
     RequestsResource,
     AsyncRequestsResource,
@@ -16,28 +8,36 @@ from .requests import (
     RequestsResourceWithStreamingResponse,
     AsyncRequestsResourceWithStreamingResponse,
 )
-from .properties import (
-    PropertiesResource,
-    AsyncPropertiesResource,
-    PropertiesResourceWithRawResponse,
-    AsyncPropertiesResourceWithRawResponse,
-    PropertiesResourceWithStreamingResponse,
-    AsyncPropertiesResourceWithStreamingResponse,
+from .request_id import (
+    RequestIDResource,
+    AsyncRequestIDResource,
+    RequestIDResourceWithRawResponse,
+    AsyncRequestIDResourceWithRawResponse,
+    RequestIDResourceWithStreamingResponse,
+    AsyncRequestIDResourceWithStreamingResponse,
+)
+from .response_id import (
+    ResponseIDResource,
+    AsyncResponseIDResource,
+    ResponseIDResourceWithRawResponse,
+    AsyncResponseIDResourceWithRawResponse,
+    ResponseIDResourceWithStreamingResponse,
+    AsyncResponseIDResourceWithStreamingResponse,
 )
 
 __all__ = [
-    "PropertiesResource",
-    "AsyncPropertiesResource",
-    "PropertiesResourceWithRawResponse",
-    "AsyncPropertiesResourceWithRawResponse",
-    "PropertiesResourceWithStreamingResponse",
-    "AsyncPropertiesResourceWithStreamingResponse",
-    "ResultResource",
-    "AsyncResultResource",
-    "ResultResourceWithRawResponse",
-    "AsyncResultResourceWithRawResponse",
-    "ResultResourceWithStreamingResponse",
-    "AsyncResultResourceWithStreamingResponse",
+    "RequestIDResource",
+    "AsyncRequestIDResource",
+    "RequestIDResourceWithRawResponse",
+    "AsyncRequestIDResourceWithRawResponse",
+    "RequestIDResourceWithStreamingResponse",
+    "AsyncRequestIDResourceWithStreamingResponse",
+    "ResponseIDResource",
+    "AsyncResponseIDResource",
+    "ResponseIDResourceWithRawResponse",
+    "AsyncResponseIDResourceWithRawResponse",
+    "ResponseIDResourceWithStreamingResponse",
+    "AsyncResponseIDResourceWithStreamingResponse",
     "RequestsResource",
     "AsyncRequestsResource",
     "RequestsResourceWithRawResponse",

payi/resources/requests/request_id/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .result import (
+    ResultResource,
+    AsyncResultResource,
+    ResultResourceWithRawResponse,
+    AsyncResultResourceWithRawResponse,
+    ResultResourceWithStreamingResponse,
+    AsyncResultResourceWithStreamingResponse,
+)
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+from .request_id import (
+    RequestIDResource,
+    AsyncRequestIDResource,
+    RequestIDResourceWithRawResponse,
+    AsyncRequestIDResourceWithRawResponse,
+    RequestIDResourceWithStreamingResponse,
+    AsyncRequestIDResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ResultResource",
+    "AsyncResultResource",
+    "ResultResourceWithRawResponse",
+    "AsyncResultResourceWithRawResponse",
+    "ResultResourceWithStreamingResponse",
+    "AsyncResultResourceWithStreamingResponse",
+    "PropertiesResource",
+    "AsyncPropertiesResource",
+    "PropertiesResourceWithRawResponse",
+    "AsyncPropertiesResourceWithRawResponse",
+    "PropertiesResourceWithStreamingResponse",
+    "AsyncPropertiesResourceWithStreamingResponse",
+    "RequestIDResource",
+    "AsyncRequestIDResource",
+    "RequestIDResourceWithRawResponse",
+    "AsyncRequestIDResourceWithRawResponse",
+    "RequestIDResourceWithStreamingResponse",
+    "AsyncRequestIDResourceWithStreamingResponse",
+]

payi/resources/requests/{properties.py → request_id/properties.py}

@@ -6,19 +6,19 @@ from typing import Dict
 
 import httpx
 
-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 (
+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.requests import property_create_params
-from ...types.shared.properties_response import PropertiesResponse
+from ...._base_client import make_request_options
+from ....types.requests.request_id import property_update_params
+from ....types.shared.properties_response import PropertiesResponse
 
 __all__ = ["PropertiesResource", "AsyncPropertiesResource"]
 
@@ -43,7 +43,7 @@ class PropertiesResource(SyncAPIResource):
         """
         return PropertiesResourceWithStreamingResponse(self)
 
-    def create(
+    def update(
         self,
         request_id: str,
         *,
@@ -69,9 +69,9 @@ class PropertiesResource(SyncAPIResource):
         """
         if not request_id:
             raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
-        return self._post(
+        return self._put(
             f"/api/v1/requests/{request_id}/properties",
-            body=maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            body=maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -99,7 +99,7 @@ class AsyncPropertiesResource(AsyncAPIResource):
         """
         return AsyncPropertiesResourceWithStreamingResponse(self)
 
-    async def create(
+    async def update(
         self,
         request_id: str,
         *,
@@ -125,9 +125,9 @@ class AsyncPropertiesResource(AsyncAPIResource):
         """
         if not request_id:
             raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
-        return await self._post(
+        return await self._put(
             f"/api/v1/requests/{request_id}/properties",
-            body=await async_maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            body=await async_maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -139,8 +139,8 @@ class PropertiesResourceWithRawResponse:
     def __init__(self, properties: PropertiesResource) -> None:
         self._properties = properties
 
-        self.create = to_raw_response_wrapper(
-            properties.create,
+        self.update = to_raw_response_wrapper(
+            properties.update,
         )
 
 
@@ -148,8 +148,8 @@ class AsyncPropertiesResourceWithRawResponse:
     def __init__(self, properties: AsyncPropertiesResource) -> None:
         self._properties = properties
 
-        self.create = async_to_raw_response_wrapper(
-            properties.create,
+        self.update = async_to_raw_response_wrapper(
+            properties.update,
         )
 
 
@@ -157,8 +157,8 @@ class PropertiesResourceWithStreamingResponse:
     def __init__(self, properties: PropertiesResource) -> None:
         self._properties = properties
 
-        self.create = to_streamed_response_wrapper(
-            properties.create,
+        self.update = to_streamed_response_wrapper(
+            properties.update,
         )
 
 
@@ -166,6 +166,6 @@ class AsyncPropertiesResourceWithStreamingResponse:
     def __init__(self, properties: AsyncPropertiesResource) -> None:
         self._properties = properties
 
-        self.create = async_to_streamed_response_wrapper(
-            properties.create,
+        self.update = async_to_streamed_response_wrapper(
+            properties.update,
         )

payi/resources/requests/request_id/request_id.py

@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .result import (
+    ResultResource,
+    AsyncResultResource,
+    ResultResourceWithRawResponse,
+    AsyncResultResourceWithRawResponse,
+    ResultResourceWithStreamingResponse,
+    AsyncResultResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["RequestIDResource", "AsyncRequestIDResource"]
+
+
+class RequestIDResource(SyncAPIResource):
+    @cached_property
+    def result(self) -> ResultResource:
+        return ResultResource(self._client)
+
+    @cached_property
+    def properties(self) -> PropertiesResource:
+        return PropertiesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> RequestIDResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return RequestIDResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RequestIDResourceWithStreamingResponse:
+        """
+        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 RequestIDResourceWithStreamingResponse(self)
+
+
+class AsyncRequestIDResource(AsyncAPIResource):
+    @cached_property
+    def result(self) -> AsyncResultResource:
+        return AsyncResultResource(self._client)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResource:
+        return AsyncPropertiesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncRequestIDResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncRequestIDResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRequestIDResourceWithStreamingResponse:
+        """
+        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 AsyncRequestIDResourceWithStreamingResponse(self)
+
+
+class RequestIDResourceWithRawResponse:
+    def __init__(self, request_id: RequestIDResource) -> None:
+        self._request_id = request_id
+
+    @cached_property
+    def result(self) -> ResultResourceWithRawResponse:
+        return ResultResourceWithRawResponse(self._request_id.result)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithRawResponse:
+        return PropertiesResourceWithRawResponse(self._request_id.properties)
+
+
+class AsyncRequestIDResourceWithRawResponse:
+    def __init__(self, request_id: AsyncRequestIDResource) -> None:
+        self._request_id = request_id
+
+    @cached_property
+    def result(self) -> AsyncResultResourceWithRawResponse:
+        return AsyncResultResourceWithRawResponse(self._request_id.result)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithRawResponse:
+        return AsyncPropertiesResourceWithRawResponse(self._request_id.properties)
+
+
+class RequestIDResourceWithStreamingResponse:
+    def __init__(self, request_id: RequestIDResource) -> None:
+        self._request_id = request_id
+
+    @cached_property
+    def result(self) -> ResultResourceWithStreamingResponse:
+        return ResultResourceWithStreamingResponse(self._request_id.result)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithStreamingResponse:
+        return PropertiesResourceWithStreamingResponse(self._request_id.properties)
+
+
+class AsyncRequestIDResourceWithStreamingResponse:
+    def __init__(self, request_id: AsyncRequestIDResource) -> None:
+        self._request_id = request_id
+
+    @cached_property
+    def result(self) -> AsyncResultResourceWithStreamingResponse:
+        return AsyncResultResourceWithStreamingResponse(self._request_id.result)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        return AsyncPropertiesResourceWithStreamingResponse(self._request_id.properties)

payi/resources/requests/{result.py → request_id/result.py}

@@ -4,17 +4,17 @@ from __future__ import annotations
 
 import httpx
 
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from ..._response import (
+from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.requests.request_result import RequestResult
+from ...._base_client import make_request_options
+from ....types.request_result import RequestResult
 
 __all__ = ["ResultResource", "AsyncResultResource"]
 
@@ -43,7 +43,6 @@ class ResultResource(SyncAPIResource):
         self,
         request_id: 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,
@@ -63,12 +62,10 @@ class ResultResource(SyncAPIResource):
 
           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 request_id:
             raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
         return self._get(
-            f"/api/v1/requests/result/{category}/{request_id}",
+            f"/api/v1/requests/{request_id}/result",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -100,7 +97,6 @@ class AsyncResultResource(AsyncAPIResource):
         self,
         request_id: 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,
@@ -120,12 +116,10 @@ class AsyncResultResource(AsyncAPIResource):
 
           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 request_id:
             raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
         return await self._get(
-            f"/api/v1/requests/result/{category}/{request_id}",
+            f"/api/v1/requests/{request_id}/result",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

payi/resources/requests/requests.py

@@ -2,36 +2,36 @@
 
 from __future__ import annotations
 
-from .result import (
-    ResultResource,
-    AsyncResultResource,
-    ResultResourceWithRawResponse,
-    AsyncResultResourceWithRawResponse,
-    ResultResourceWithStreamingResponse,
-    AsyncResultResourceWithStreamingResponse,
-)
 from ..._compat import cached_property
-from .properties import (
-    PropertiesResource,
-    AsyncPropertiesResource,
-    PropertiesResourceWithRawResponse,
-    AsyncPropertiesResourceWithRawResponse,
-    PropertiesResourceWithStreamingResponse,
-    AsyncPropertiesResourceWithStreamingResponse,
-)
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .request_id.request_id import (
+    RequestIDResource,
+    AsyncRequestIDResource,
+    RequestIDResourceWithRawResponse,
+    AsyncRequestIDResourceWithRawResponse,
+    RequestIDResourceWithStreamingResponse,
+    AsyncRequestIDResourceWithStreamingResponse,
+)
+from .response_id.response_id import (
+    ResponseIDResource,
+    AsyncResponseIDResource,
+    ResponseIDResourceWithRawResponse,
+    AsyncResponseIDResourceWithRawResponse,
+    ResponseIDResourceWithStreamingResponse,
+    AsyncResponseIDResourceWithStreamingResponse,
+)
 
 __all__ = ["RequestsResource", "AsyncRequestsResource"]
 
 
 class RequestsResource(SyncAPIResource):
     @cached_property
-    def properties(self) -> PropertiesResource:
-        return PropertiesResource(self._client)
+    def request_id(self) -> RequestIDResource:
+        return RequestIDResource(self._client)
 
     @cached_property
-    def result(self) -> ResultResource:
-        return ResultResource(self._client)
+    def response_id(self) -> ResponseIDResource:
+        return ResponseIDResource(self._client)
 
     @cached_property
     def with_raw_response(self) -> RequestsResourceWithRawResponse:
@@ -55,12 +55,12 @@ class RequestsResource(SyncAPIResource):
 
 class AsyncRequestsResource(AsyncAPIResource):
     @cached_property
-    def properties(self) -> AsyncPropertiesResource:
-        return AsyncPropertiesResource(self._client)
+    def request_id(self) -> AsyncRequestIDResource:
+        return AsyncRequestIDResource(self._client)
 
     @cached_property
-    def result(self) -> AsyncResultResource:
-        return AsyncResultResource(self._client)
+    def response_id(self) -> AsyncResponseIDResource:
+        return AsyncResponseIDResource(self._client)
 
     @cached_property
     def with_raw_response(self) -> AsyncRequestsResourceWithRawResponse:
@@ -87,12 +87,12 @@ class RequestsResourceWithRawResponse:
         self._requests = requests
 
     @cached_property
-    def properties(self) -> PropertiesResourceWithRawResponse:
-        return PropertiesResourceWithRawResponse(self._requests.properties)
+    def request_id(self) -> RequestIDResourceWithRawResponse:
+        return RequestIDResourceWithRawResponse(self._requests.request_id)
 
     @cached_property
-    def result(self) -> ResultResourceWithRawResponse:
-        return ResultResourceWithRawResponse(self._requests.result)
+    def response_id(self) -> ResponseIDResourceWithRawResponse:
+        return ResponseIDResourceWithRawResponse(self._requests.response_id)
 
 
 class AsyncRequestsResourceWithRawResponse:
@@ -100,12 +100,12 @@ class AsyncRequestsResourceWithRawResponse:
         self._requests = requests
 
     @cached_property
-    def properties(self) -> AsyncPropertiesResourceWithRawResponse:
-        return AsyncPropertiesResourceWithRawResponse(self._requests.properties)
+    def request_id(self) -> AsyncRequestIDResourceWithRawResponse:
+        return AsyncRequestIDResourceWithRawResponse(self._requests.request_id)
 
     @cached_property
-    def result(self) -> AsyncResultResourceWithRawResponse:
-        return AsyncResultResourceWithRawResponse(self._requests.result)
+    def response_id(self) -> AsyncResponseIDResourceWithRawResponse:
+        return AsyncResponseIDResourceWithRawResponse(self._requests.response_id)
 
 
 class RequestsResourceWithStreamingResponse:
@@ -113,12 +113,12 @@ class RequestsResourceWithStreamingResponse:
         self._requests = requests
 
     @cached_property
-    def properties(self) -> PropertiesResourceWithStreamingResponse:
-        return PropertiesResourceWithStreamingResponse(self._requests.properties)
+    def request_id(self) -> RequestIDResourceWithStreamingResponse:
+        return RequestIDResourceWithStreamingResponse(self._requests.request_id)
 
     @cached_property
-    def result(self) -> ResultResourceWithStreamingResponse:
-        return ResultResourceWithStreamingResponse(self._requests.result)
+    def response_id(self) -> ResponseIDResourceWithStreamingResponse:
+        return ResponseIDResourceWithStreamingResponse(self._requests.response_id)
 
 
 class AsyncRequestsResourceWithStreamingResponse:
@@ -126,9 +126,9 @@ class AsyncRequestsResourceWithStreamingResponse:
         self._requests = requests
 
     @cached_property
-    def properties(self) -> AsyncPropertiesResourceWithStreamingResponse:
-        return AsyncPropertiesResourceWithStreamingResponse(self._requests.properties)
+    def request_id(self) -> AsyncRequestIDResourceWithStreamingResponse:
+        return AsyncRequestIDResourceWithStreamingResponse(self._requests.request_id)
 
     @cached_property
-    def result(self) -> AsyncResultResourceWithStreamingResponse:
-        return AsyncResultResourceWithStreamingResponse(self._requests.result)
+    def response_id(self) -> AsyncResponseIDResourceWithStreamingResponse:
+        return AsyncResponseIDResourceWithStreamingResponse(self._requests.response_id)

payi/resources/requests/response_id/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .result import (
+    ResultResource,
+    AsyncResultResource,
+    ResultResourceWithRawResponse,
+    AsyncResultResourceWithRawResponse,
+    ResultResourceWithStreamingResponse,
+    AsyncResultResourceWithStreamingResponse,
+)
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+from .response_id import (
+    ResponseIDResource,
+    AsyncResponseIDResource,
+    ResponseIDResourceWithRawResponse,
+    AsyncResponseIDResourceWithRawResponse,
+    ResponseIDResourceWithStreamingResponse,
+    AsyncResponseIDResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ResultResource",
+    "AsyncResultResource",
+    "ResultResourceWithRawResponse",
+    "AsyncResultResourceWithRawResponse",
+    "ResultResourceWithStreamingResponse",
+    "AsyncResultResourceWithStreamingResponse",
+    "PropertiesResource",
+    "AsyncPropertiesResource",
+    "PropertiesResourceWithRawResponse",
+    "AsyncPropertiesResourceWithRawResponse",
+    "PropertiesResourceWithStreamingResponse",
+    "AsyncPropertiesResourceWithStreamingResponse",
+    "ResponseIDResource",
+    "AsyncResponseIDResource",
+    "ResponseIDResourceWithRawResponse",
+    "AsyncResponseIDResourceWithRawResponse",
+    "ResponseIDResourceWithStreamingResponse",
+    "AsyncResponseIDResourceWithStreamingResponse",
+]