linq-python 0.20.0__tar.gz → 0.21.0__tar.gz

linq_python-0.21.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.21.0"
+}

{linq_python-0.20.0 → linq_python-0.21.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.21.0](https://github.com/linq-team/linq-python/compare/v0.20.0...v0.21.0) (2026-08-10)
+
+
+### Features
+
+* add blocked handles api for managing inbound message filtering ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+* add diagnostic fields to message failure webhook events ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+* regenerate SDKs from updated API spec ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+
+
+### Bug Fixes
+
+* clarify opted-out status clearing behavior in chat health ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+* clarify stop keyword behavior and matching rules ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+* clarify stop keyword behavior for multi-chat replies ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+* expand webhook error code documentation for failure events ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+
+
+### Documentation
+
+* clarify presigned url behavior and configuration ([b8f2f87](https://github.com/linq-team/linq-python/commit/b8f2f87a8cd442f876fd05a49b79f37f9d8b3cb2))
+
 ## [0.20.0](https://github.com/linq-team/linq-python/compare/v0.19.1...v0.20.0) (2026-08-05)
 
 

{linq_python-0.20.0 → linq_python-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: linq-python
-Version: 0.20.0
+Version: 0.21.0
 Summary: The official Python library for the linq-api-v3 API
 Project-URL: Homepage, https://github.com/linq-team/linq-python
 Project-URL: Repository, https://github.com/linq-team/linq-python

{linq_python-0.20.0 → linq_python-0.21.0}/api.md

@@ -242,6 +242,20 @@ Methods:
 - <code title="post /v3/payments/{paymentId}/cancel">client.payments.<a href="./src/linq/resources/payments.py">cancel</a>(payment_id) -> <a href="./src/linq/types/payment.py">Payment</a></code>
 - <code title="get /v3/payments/{paymentId}/credentials">client.payments.<a href="./src/linq/resources/payments.py">credentials</a>(payment_id) -> <a href="./src/linq/types/payment_credentials_response.py">PaymentCredentialsResponse</a></code>
 
+# BlockedHandles
+
+Types:
+
+```python
+from linq.types import BlockedHandleEntry, BlockedHandleListResponse, BlockedHandleBlockResponse
+```
+
+Methods:
+
+- <code title="get /v3/blocked_handles">client.blocked_handles.<a href="./src/linq/resources/blocked_handles.py">list</a>() -> <a href="./src/linq/types/blocked_handle_list_response.py">BlockedHandleListResponse</a></code>
+- <code title="post /v3/blocked_handles">client.blocked_handles.<a href="./src/linq/resources/blocked_handles.py">block</a>(\*\*<a href="src/linq/types/blocked_handle_block_params.py">params</a>) -> <a href="./src/linq/types/blocked_handle_block_response.py">BlockedHandleBlockResponse</a></code>
+- <code title="delete /v3/blocked_handles">client.blocked_handles.<a href="./src/linq/resources/blocked_handles.py">unblock</a>(\*\*<a href="src/linq/types/blocked_handle_unblock_params.py">params</a>) -> None</code>
+
 # Experiences
 
 Types:

{linq_python-0.20.0 → linq_python-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linq-python"
-version = "0.20.0"
+version = "0.21.0"
 description = "The official Python library for the linq-api-v3 API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{linq_python-0.20.0 → linq_python-0.21.0}/src/linq/_client.py

@@ -48,6 +48,7 @@ if TYPE_CHECKING:
         phonenumbers,
         phone_numbers,
         webhook_events,
+        blocked_handles,
         payment_handles,
         available_number,
         payment_requests,
@@ -64,6 +65,7 @@ if TYPE_CHECKING:
     from .resources.phonenumbers import PhonenumbersResource, AsyncPhonenumbersResource
     from .resources.phone_numbers import PhoneNumbersResource, AsyncPhoneNumbersResource
     from .resources.webhook_events import WebhookEventsResource, AsyncWebhookEventsResource
+    from .resources.blocked_handles import BlockedHandlesResource, AsyncBlockedHandlesResource
     from .resources.payment_handles import PaymentHandlesResource, AsyncPaymentHandlesResource
     from .resources.available_number import AvailableNumberResource, AsyncAvailableNumberResource
     from .resources.payment_requests import PaymentRequestsResource, AsyncPaymentRequestsResource
@@ -607,6 +609,20 @@ class LinqAPIV3(SyncAPIClient):
 
         return PaymentsResource(self)
 
+    @cached_property
+    def blocked_handles(self) -> BlockedHandlesResource:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import BlockedHandlesResource
+
+        return BlockedHandlesResource(self)
+
     @cached_property
     def experiences(self) -> ExperiencesResource:
         """
@@ -1561,6 +1577,20 @@ class AsyncLinqAPIV3(AsyncAPIClient):
 
         return AsyncPaymentsResource(self)
 
+    @cached_property
+    def blocked_handles(self) -> AsyncBlockedHandlesResource:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import AsyncBlockedHandlesResource
+
+        return AsyncBlockedHandlesResource(self)
+
     @cached_property
     def experiences(self) -> AsyncExperiencesResource:
         """
@@ -2449,6 +2479,20 @@ class LinqAPIV3WithRawResponse:
 
         return PaymentsResourceWithRawResponse(self._client.payments)
 
+    @cached_property
+    def blocked_handles(self) -> blocked_handles.BlockedHandlesResourceWithRawResponse:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import BlockedHandlesResourceWithRawResponse
+
+        return BlockedHandlesResourceWithRawResponse(self._client.blocked_handles)
+
     @cached_property
     def experiences(self) -> experiences.ExperiencesResourceWithRawResponse:
         """
@@ -3209,6 +3253,20 @@ class AsyncLinqAPIV3WithRawResponse:
 
         return AsyncPaymentsResourceWithRawResponse(self._client.payments)
 
+    @cached_property
+    def blocked_handles(self) -> blocked_handles.AsyncBlockedHandlesResourceWithRawResponse:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import AsyncBlockedHandlesResourceWithRawResponse
+
+        return AsyncBlockedHandlesResourceWithRawResponse(self._client.blocked_handles)
+
     @cached_property
     def experiences(self) -> experiences.AsyncExperiencesResourceWithRawResponse:
         """
@@ -3969,6 +4027,20 @@ class LinqAPIV3WithStreamedResponse:
 
         return PaymentsResourceWithStreamingResponse(self._client.payments)
 
+    @cached_property
+    def blocked_handles(self) -> blocked_handles.BlockedHandlesResourceWithStreamingResponse:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import BlockedHandlesResourceWithStreamingResponse
+
+        return BlockedHandlesResourceWithStreamingResponse(self._client.blocked_handles)
+
     @cached_property
     def experiences(self) -> experiences.ExperiencesResourceWithStreamingResponse:
         """
@@ -4729,6 +4801,20 @@ class AsyncLinqAPIV3WithStreamedResponse:
 
         return AsyncPaymentsResourceWithStreamingResponse(self._client.payments)
 
+    @cached_property
+    def blocked_handles(self) -> blocked_handles.AsyncBlockedHandlesResourceWithStreamingResponse:
+        """Block handles — phone numbers, email addresses, SMS short codes, or
+        sender IDs.
+
+        Inbound messages from a blocked handle are dropped before
+        they reach your webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include
+        unblocked members are not restricted.
+        """
+        from .resources.blocked_handles import AsyncBlockedHandlesResourceWithStreamingResponse
+
+        return AsyncBlockedHandlesResourceWithStreamingResponse(self._client.blocked_handles)
+
     @cached_property
     def experiences(self) -> experiences.AsyncExperiencesResourceWithStreamingResponse:
         """

{linq_python-0.20.0 → linq_python-0.21.0}/src/linq/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "linq"
-__version__ = "0.20.0"  # x-release-please-version
+__version__ = "0.21.0"  # x-release-please-version

{linq_python-0.20.0 → linq_python-0.21.0}/src/linq/resources/__init__.py

@@ -81,6 +81,14 @@ from .webhook_events import (
     WebhookEventsResourceWithStreamingResponse,
     AsyncWebhookEventsResourceWithStreamingResponse,
 )
+from .blocked_handles import (
+    BlockedHandlesResource,
+    AsyncBlockedHandlesResource,
+    BlockedHandlesResourceWithRawResponse,
+    AsyncBlockedHandlesResourceWithRawResponse,
+    BlockedHandlesResourceWithStreamingResponse,
+    AsyncBlockedHandlesResourceWithStreamingResponse,
+)
 from .payment_handles import (
     PaymentHandlesResource,
     AsyncPaymentHandlesResource,
@@ -183,6 +191,12 @@ __all__ = [
     "AsyncPaymentsResourceWithRawResponse",
     "PaymentsResourceWithStreamingResponse",
     "AsyncPaymentsResourceWithStreamingResponse",
+    "BlockedHandlesResource",
+    "AsyncBlockedHandlesResource",
+    "BlockedHandlesResourceWithRawResponse",
+    "AsyncBlockedHandlesResourceWithRawResponse",
+    "BlockedHandlesResourceWithStreamingResponse",
+    "AsyncBlockedHandlesResourceWithStreamingResponse",
     "ExperiencesResource",
     "AsyncExperiencesResource",
     "ExperiencesResourceWithRawResponse",

linq_python-0.21.0/src/linq/resources/blocked_handles.py

@@ -0,0 +1,368 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import blocked_handle_block_params, blocked_handle_unblock_params
+from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
+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.blocked_handle_list_response import BlockedHandleListResponse
+from ..types.blocked_handle_block_response import BlockedHandleBlockResponse
+
+__all__ = ["BlockedHandlesResource", "AsyncBlockedHandlesResource"]
+
+
+class BlockedHandlesResource(SyncAPIResource):
+    """Block handles — phone numbers, email addresses, SMS short codes, or
+    sender IDs.
+
+    Inbound messages from a blocked handle are dropped before
+    they reach your webhooks, and direct sends to a blocked handle are
+    rejected with `403` (error code `2026`). Group sends that include
+    unblocked members are not restricted.
+    """
+
+    @cached_property
+    def with_raw_response(self) -> BlockedHandlesResourceWithRawResponse:
+        """
+        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/linq-team/linq-python#accessing-raw-response-data-eg-headers
+        """
+        return BlockedHandlesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BlockedHandlesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/linq-team/linq-python#with_streaming_response
+        """
+        return BlockedHandlesResourceWithStreamingResponse(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,
+    ) -> BlockedHandleListResponse:
+        """Returns all handles you have blocked.
+
+        Inbound messages from a blocked handle are
+        dropped and produce no webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include unblocked
+        members are not restricted.
+        """
+        return self._get(
+            "/v3/blocked_handles",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BlockedHandleListResponse,
+        )
+
+    def block(
+        self,
+        *,
+        handle: str,
+        reason: str | Omit = omit,
+        # 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,
+    ) -> BlockedHandleBlockResponse:
+        """
+        Blocks a handle — an E.164 phone number, an email address (iMessage sender), an
+        SMS short code (e.g. `262966`), or an alphanumeric sender ID. Inbound messages
+        from it are dropped and produce no webhooks, and direct sends to it are rejected
+        with `403` (error code `2026`); group sends that include unblocked members are
+        not restricted. Blocking is idempotent — re-blocking an already blocked handle
+        returns the existing entry.
+
+        Args:
+          handle: The handle to block: an E.164 phone number, an email address, an SMS short code
+              (3-8 digits), or an alphanumeric sender ID.
+
+          reason: Optional free-text note on why the handle was blocked
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v3/blocked_handles",
+            body=maybe_transform(
+                {
+                    "handle": handle,
+                    "reason": reason,
+                },
+                blocked_handle_block_params.BlockedHandleBlockParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BlockedHandleBlockResponse,
+        )
+
+    def unblock(
+        self,
+        *,
+        handle: 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,
+    ) -> None:
+        """Removes a handle from your blocklist.
+
+        Inbound messages from it will be delivered
+        again and sends to it are allowed again. The handle goes in the request body,
+        mirroring block — no URL encoding needed.
+
+        Args:
+          handle: The handle to unblock
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            "/v3/blocked_handles",
+            body=maybe_transform({"handle": handle}, blocked_handle_unblock_params.BlockedHandleUnblockParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncBlockedHandlesResource(AsyncAPIResource):
+    """Block handles — phone numbers, email addresses, SMS short codes, or
+    sender IDs.
+
+    Inbound messages from a blocked handle are dropped before
+    they reach your webhooks, and direct sends to a blocked handle are
+    rejected with `403` (error code `2026`). Group sends that include
+    unblocked members are not restricted.
+    """
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBlockedHandlesResourceWithRawResponse:
+        """
+        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/linq-team/linq-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBlockedHandlesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBlockedHandlesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/linq-team/linq-python#with_streaming_response
+        """
+        return AsyncBlockedHandlesResourceWithStreamingResponse(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,
+    ) -> BlockedHandleListResponse:
+        """Returns all handles you have blocked.
+
+        Inbound messages from a blocked handle are
+        dropped and produce no webhooks, and direct sends to a blocked handle are
+        rejected with `403` (error code `2026`). Group sends that include unblocked
+        members are not restricted.
+        """
+        return await self._get(
+            "/v3/blocked_handles",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BlockedHandleListResponse,
+        )
+
+    async def block(
+        self,
+        *,
+        handle: str,
+        reason: str | Omit = omit,
+        # 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,
+    ) -> BlockedHandleBlockResponse:
+        """
+        Blocks a handle — an E.164 phone number, an email address (iMessage sender), an
+        SMS short code (e.g. `262966`), or an alphanumeric sender ID. Inbound messages
+        from it are dropped and produce no webhooks, and direct sends to it are rejected
+        with `403` (error code `2026`); group sends that include unblocked members are
+        not restricted. Blocking is idempotent — re-blocking an already blocked handle
+        returns the existing entry.
+
+        Args:
+          handle: The handle to block: an E.164 phone number, an email address, an SMS short code
+              (3-8 digits), or an alphanumeric sender ID.
+
+          reason: Optional free-text note on why the handle was blocked
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v3/blocked_handles",
+            body=await async_maybe_transform(
+                {
+                    "handle": handle,
+                    "reason": reason,
+                },
+                blocked_handle_block_params.BlockedHandleBlockParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BlockedHandleBlockResponse,
+        )
+
+    async def unblock(
+        self,
+        *,
+        handle: 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,
+    ) -> None:
+        """Removes a handle from your blocklist.
+
+        Inbound messages from it will be delivered
+        again and sends to it are allowed again. The handle goes in the request body,
+        mirroring block — no URL encoding needed.
+
+        Args:
+          handle: The handle to unblock
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            "/v3/blocked_handles",
+            body=await async_maybe_transform(
+                {"handle": handle}, blocked_handle_unblock_params.BlockedHandleUnblockParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class BlockedHandlesResourceWithRawResponse:
+    def __init__(self, blocked_handles: BlockedHandlesResource) -> None:
+        self._blocked_handles = blocked_handles
+
+        self.list = to_raw_response_wrapper(
+            blocked_handles.list,
+        )
+        self.block = to_raw_response_wrapper(
+            blocked_handles.block,
+        )
+        self.unblock = to_raw_response_wrapper(
+            blocked_handles.unblock,
+        )
+
+
+class AsyncBlockedHandlesResourceWithRawResponse:
+    def __init__(self, blocked_handles: AsyncBlockedHandlesResource) -> None:
+        self._blocked_handles = blocked_handles
+
+        self.list = async_to_raw_response_wrapper(
+            blocked_handles.list,
+        )
+        self.block = async_to_raw_response_wrapper(
+            blocked_handles.block,
+        )
+        self.unblock = async_to_raw_response_wrapper(
+            blocked_handles.unblock,
+        )
+
+
+class BlockedHandlesResourceWithStreamingResponse:
+    def __init__(self, blocked_handles: BlockedHandlesResource) -> None:
+        self._blocked_handles = blocked_handles
+
+        self.list = to_streamed_response_wrapper(
+            blocked_handles.list,
+        )
+        self.block = to_streamed_response_wrapper(
+            blocked_handles.block,
+        )
+        self.unblock = to_streamed_response_wrapper(
+            blocked_handles.unblock,
+        )
+
+
+class AsyncBlockedHandlesResourceWithStreamingResponse:
+    def __init__(self, blocked_handles: AsyncBlockedHandlesResource) -> None:
+        self._blocked_handles = blocked_handles
+
+        self.list = async_to_streamed_response_wrapper(
+            blocked_handles.list,
+        )
+        self.block = async_to_streamed_response_wrapper(
+            blocked_handles.block,
+        )
+        self.unblock = async_to_streamed_response_wrapper(
+            blocked_handles.unblock,
+        )