casedev 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

casedev/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, Mapping, cast
+from typing import TYPE_CHECKING, Any, Dict, Mapping, cast
 from typing_extensions import Self, Literal, override
 
 import httpx
@@ -20,6 +20,7 @@ from ._types import (
     not_given,
 )
 from ._utils import is_given, get_async_library
+from ._compat import cached_property
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import CasedevError, APIStatusError
@@ -28,18 +29,16 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.llm import llm
-from .resources.ocr import ocr
-from .resources.vault import vault
-from .resources.voice import voice
-from .resources.format import format
-from .resources.search import search
-from .resources.actions import actions
-from .resources.compute import compute
-from .resources.convert import convert
-from .resources.webhooks import webhooks
-from .resources.templates import templates
-from .resources.workflows import workflows
+
+if TYPE_CHECKING:
+    from .resources import llm, ocr, vault, voice, format, search, compute
+    from .resources.llm.llm import LlmResource, AsyncLlmResource
+    from .resources.ocr.ocr import OcrResource, AsyncOcrResource
+    from .resources.vault.vault import VaultResource, AsyncVaultResource
+    from .resources.voice.voice import VoiceResource, AsyncVoiceResource
+    from .resources.format.format import FormatResource, AsyncFormatResource
+    from .resources.search.search import SearchResource, AsyncSearchResource
+    from .resources.compute.compute import ComputeResource, AsyncComputeResource
 
 __all__ = [
     "ENVIRONMENTS",
@@ -60,21 +59,6 @@ ENVIRONMENTS: Dict[str, str] = {
 
 
 class Casedev(SyncAPIClient):
-    actions: actions.ActionsResource
-    compute: compute.ComputeResource
-    convert: convert.ConvertResource
-    format: format.FormatResource
-    llm: llm.LlmResource
-    ocr: ocr.OcrResource
-    search: search.SearchResource
-    vault: vault.VaultResource
-    voice: voice.VoiceResource
-    webhooks: webhooks.WebhooksResource
-    templates: templates.TemplatesResource
-    workflows: workflows.WorkflowsResource
-    with_raw_response: CasedevWithRawResponse
-    with_streaming_response: CasedevWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -153,20 +137,55 @@ class Casedev(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.actions = actions.ActionsResource(self)
-        self.compute = compute.ComputeResource(self)
-        self.convert = convert.ConvertResource(self)
-        self.format = format.FormatResource(self)
-        self.llm = llm.LlmResource(self)
-        self.ocr = ocr.OcrResource(self)
-        self.search = search.SearchResource(self)
-        self.vault = vault.VaultResource(self)
-        self.voice = voice.VoiceResource(self)
-        self.webhooks = webhooks.WebhooksResource(self)
-        self.templates = templates.TemplatesResource(self)
-        self.workflows = workflows.WorkflowsResource(self)
-        self.with_raw_response = CasedevWithRawResponse(self)
-        self.with_streaming_response = CasedevWithStreamedResponse(self)
+    @cached_property
+    def compute(self) -> ComputeResource:
+        from .resources.compute import ComputeResource
+
+        return ComputeResource(self)
+
+    @cached_property
+    def format(self) -> FormatResource:
+        from .resources.format import FormatResource
+
+        return FormatResource(self)
+
+    @cached_property
+    def llm(self) -> LlmResource:
+        from .resources.llm import LlmResource
+
+        return LlmResource(self)
+
+    @cached_property
+    def ocr(self) -> OcrResource:
+        from .resources.ocr import OcrResource
+
+        return OcrResource(self)
+
+    @cached_property
+    def search(self) -> SearchResource:
+        from .resources.search import SearchResource
+
+        return SearchResource(self)
+
+    @cached_property
+    def vault(self) -> VaultResource:
+        from .resources.vault import VaultResource
+
+        return VaultResource(self)
+
+    @cached_property
+    def voice(self) -> VoiceResource:
+        from .resources.voice import VoiceResource
+
+        return VoiceResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> CasedevWithRawResponse:
+        return CasedevWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CasedevWithStreamedResponse:
+        return CasedevWithStreamedResponse(self)
 
     @property
     @override
@@ -276,21 +295,6 @@ class Casedev(SyncAPIClient):
 
 
 class AsyncCasedev(AsyncAPIClient):
-    actions: actions.AsyncActionsResource
-    compute: compute.AsyncComputeResource
-    convert: convert.AsyncConvertResource
-    format: format.AsyncFormatResource
-    llm: llm.AsyncLlmResource
-    ocr: ocr.AsyncOcrResource
-    search: search.AsyncSearchResource
-    vault: vault.AsyncVaultResource
-    voice: voice.AsyncVoiceResource
-    webhooks: webhooks.AsyncWebhooksResource
-    templates: templates.AsyncTemplatesResource
-    workflows: workflows.AsyncWorkflowsResource
-    with_raw_response: AsyncCasedevWithRawResponse
-    with_streaming_response: AsyncCasedevWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -369,20 +373,55 @@ class AsyncCasedev(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.actions = actions.AsyncActionsResource(self)
-        self.compute = compute.AsyncComputeResource(self)
-        self.convert = convert.AsyncConvertResource(self)
-        self.format = format.AsyncFormatResource(self)
-        self.llm = llm.AsyncLlmResource(self)
-        self.ocr = ocr.AsyncOcrResource(self)
-        self.search = search.AsyncSearchResource(self)
-        self.vault = vault.AsyncVaultResource(self)
-        self.voice = voice.AsyncVoiceResource(self)
-        self.webhooks = webhooks.AsyncWebhooksResource(self)
-        self.templates = templates.AsyncTemplatesResource(self)
-        self.workflows = workflows.AsyncWorkflowsResource(self)
-        self.with_raw_response = AsyncCasedevWithRawResponse(self)
-        self.with_streaming_response = AsyncCasedevWithStreamedResponse(self)
+    @cached_property
+    def compute(self) -> AsyncComputeResource:
+        from .resources.compute import AsyncComputeResource
+
+        return AsyncComputeResource(self)
+
+    @cached_property
+    def format(self) -> AsyncFormatResource:
+        from .resources.format import AsyncFormatResource
+
+        return AsyncFormatResource(self)
+
+    @cached_property
+    def llm(self) -> AsyncLlmResource:
+        from .resources.llm import AsyncLlmResource
+
+        return AsyncLlmResource(self)
+
+    @cached_property
+    def ocr(self) -> AsyncOcrResource:
+        from .resources.ocr import AsyncOcrResource
+
+        return AsyncOcrResource(self)
+
+    @cached_property
+    def search(self) -> AsyncSearchResource:
+        from .resources.search import AsyncSearchResource
+
+        return AsyncSearchResource(self)
+
+    @cached_property
+    def vault(self) -> AsyncVaultResource:
+        from .resources.vault import AsyncVaultResource
+
+        return AsyncVaultResource(self)
+
+    @cached_property
+    def voice(self) -> AsyncVoiceResource:
+        from .resources.voice import AsyncVoiceResource
+
+        return AsyncVoiceResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncCasedevWithRawResponse:
+        return AsyncCasedevWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCasedevWithStreamedResponse:
+        return AsyncCasedevWithStreamedResponse(self)
 
     @property
     @override
@@ -492,67 +531,199 @@ class AsyncCasedev(AsyncAPIClient):
 
 
 class CasedevWithRawResponse:
+    _client: Casedev
+
     def __init__(self, client: Casedev) -> None:
-        self.actions = actions.ActionsResourceWithRawResponse(client.actions)
-        self.compute = compute.ComputeResourceWithRawResponse(client.compute)
-        self.convert = convert.ConvertResourceWithRawResponse(client.convert)
-        self.format = format.FormatResourceWithRawResponse(client.format)
-        self.llm = llm.LlmResourceWithRawResponse(client.llm)
-        self.ocr = ocr.OcrResourceWithRawResponse(client.ocr)
-        self.search = search.SearchResourceWithRawResponse(client.search)
-        self.vault = vault.VaultResourceWithRawResponse(client.vault)
-        self.voice = voice.VoiceResourceWithRawResponse(client.voice)
-        self.webhooks = webhooks.WebhooksResourceWithRawResponse(client.webhooks)
-        self.templates = templates.TemplatesResourceWithRawResponse(client.templates)
-        self.workflows = workflows.WorkflowsResourceWithRawResponse(client.workflows)
+        self._client = client
+
+    @cached_property
+    def compute(self) -> compute.ComputeResourceWithRawResponse:
+        from .resources.compute import ComputeResourceWithRawResponse
+
+        return ComputeResourceWithRawResponse(self._client.compute)
+
+    @cached_property
+    def format(self) -> format.FormatResourceWithRawResponse:
+        from .resources.format import FormatResourceWithRawResponse
+
+        return FormatResourceWithRawResponse(self._client.format)
+
+    @cached_property
+    def llm(self) -> llm.LlmResourceWithRawResponse:
+        from .resources.llm import LlmResourceWithRawResponse
+
+        return LlmResourceWithRawResponse(self._client.llm)
+
+    @cached_property
+    def ocr(self) -> ocr.OcrResourceWithRawResponse:
+        from .resources.ocr import OcrResourceWithRawResponse
+
+        return OcrResourceWithRawResponse(self._client.ocr)
+
+    @cached_property
+    def search(self) -> search.SearchResourceWithRawResponse:
+        from .resources.search import SearchResourceWithRawResponse
+
+        return SearchResourceWithRawResponse(self._client.search)
+
+    @cached_property
+    def vault(self) -> vault.VaultResourceWithRawResponse:
+        from .resources.vault import VaultResourceWithRawResponse
+
+        return VaultResourceWithRawResponse(self._client.vault)
+
+    @cached_property
+    def voice(self) -> voice.VoiceResourceWithRawResponse:
+        from .resources.voice import VoiceResourceWithRawResponse
+
+        return VoiceResourceWithRawResponse(self._client.voice)
 
 
 class AsyncCasedevWithRawResponse:
+    _client: AsyncCasedev
+
     def __init__(self, client: AsyncCasedev) -> None:
-        self.actions = actions.AsyncActionsResourceWithRawResponse(client.actions)
-        self.compute = compute.AsyncComputeResourceWithRawResponse(client.compute)
-        self.convert = convert.AsyncConvertResourceWithRawResponse(client.convert)
-        self.format = format.AsyncFormatResourceWithRawResponse(client.format)
-        self.llm = llm.AsyncLlmResourceWithRawResponse(client.llm)
-        self.ocr = ocr.AsyncOcrResourceWithRawResponse(client.ocr)
-        self.search = search.AsyncSearchResourceWithRawResponse(client.search)
-        self.vault = vault.AsyncVaultResourceWithRawResponse(client.vault)
-        self.voice = voice.AsyncVoiceResourceWithRawResponse(client.voice)
-        self.webhooks = webhooks.AsyncWebhooksResourceWithRawResponse(client.webhooks)
-        self.templates = templates.AsyncTemplatesResourceWithRawResponse(client.templates)
-        self.workflows = workflows.AsyncWorkflowsResourceWithRawResponse(client.workflows)
+        self._client = client
+
+    @cached_property
+    def compute(self) -> compute.AsyncComputeResourceWithRawResponse:
+        from .resources.compute import AsyncComputeResourceWithRawResponse
+
+        return AsyncComputeResourceWithRawResponse(self._client.compute)
+
+    @cached_property
+    def format(self) -> format.AsyncFormatResourceWithRawResponse:
+        from .resources.format import AsyncFormatResourceWithRawResponse
+
+        return AsyncFormatResourceWithRawResponse(self._client.format)
+
+    @cached_property
+    def llm(self) -> llm.AsyncLlmResourceWithRawResponse:
+        from .resources.llm import AsyncLlmResourceWithRawResponse
+
+        return AsyncLlmResourceWithRawResponse(self._client.llm)
+
+    @cached_property
+    def ocr(self) -> ocr.AsyncOcrResourceWithRawResponse:
+        from .resources.ocr import AsyncOcrResourceWithRawResponse
+
+        return AsyncOcrResourceWithRawResponse(self._client.ocr)
+
+    @cached_property
+    def search(self) -> search.AsyncSearchResourceWithRawResponse:
+        from .resources.search import AsyncSearchResourceWithRawResponse
+
+        return AsyncSearchResourceWithRawResponse(self._client.search)
+
+    @cached_property
+    def vault(self) -> vault.AsyncVaultResourceWithRawResponse:
+        from .resources.vault import AsyncVaultResourceWithRawResponse
+
+        return AsyncVaultResourceWithRawResponse(self._client.vault)
+
+    @cached_property
+    def voice(self) -> voice.AsyncVoiceResourceWithRawResponse:
+        from .resources.voice import AsyncVoiceResourceWithRawResponse
+
+        return AsyncVoiceResourceWithRawResponse(self._client.voice)
 
 
 class CasedevWithStreamedResponse:
+    _client: Casedev
+
     def __init__(self, client: Casedev) -> None:
-        self.actions = actions.ActionsResourceWithStreamingResponse(client.actions)
-        self.compute = compute.ComputeResourceWithStreamingResponse(client.compute)
-        self.convert = convert.ConvertResourceWithStreamingResponse(client.convert)
-        self.format = format.FormatResourceWithStreamingResponse(client.format)
-        self.llm = llm.LlmResourceWithStreamingResponse(client.llm)
-        self.ocr = ocr.OcrResourceWithStreamingResponse(client.ocr)
-        self.search = search.SearchResourceWithStreamingResponse(client.search)
-        self.vault = vault.VaultResourceWithStreamingResponse(client.vault)
-        self.voice = voice.VoiceResourceWithStreamingResponse(client.voice)
-        self.webhooks = webhooks.WebhooksResourceWithStreamingResponse(client.webhooks)
-        self.templates = templates.TemplatesResourceWithStreamingResponse(client.templates)
-        self.workflows = workflows.WorkflowsResourceWithStreamingResponse(client.workflows)
+        self._client = client
+
+    @cached_property
+    def compute(self) -> compute.ComputeResourceWithStreamingResponse:
+        from .resources.compute import ComputeResourceWithStreamingResponse
+
+        return ComputeResourceWithStreamingResponse(self._client.compute)
+
+    @cached_property
+    def format(self) -> format.FormatResourceWithStreamingResponse:
+        from .resources.format import FormatResourceWithStreamingResponse
+
+        return FormatResourceWithStreamingResponse(self._client.format)
+
+    @cached_property
+    def llm(self) -> llm.LlmResourceWithStreamingResponse:
+        from .resources.llm import LlmResourceWithStreamingResponse
+
+        return LlmResourceWithStreamingResponse(self._client.llm)
+
+    @cached_property
+    def ocr(self) -> ocr.OcrResourceWithStreamingResponse:
+        from .resources.ocr import OcrResourceWithStreamingResponse
+
+        return OcrResourceWithStreamingResponse(self._client.ocr)
+
+    @cached_property
+    def search(self) -> search.SearchResourceWithStreamingResponse:
+        from .resources.search import SearchResourceWithStreamingResponse
+
+        return SearchResourceWithStreamingResponse(self._client.search)
+
+    @cached_property
+    def vault(self) -> vault.VaultResourceWithStreamingResponse:
+        from .resources.vault import VaultResourceWithStreamingResponse
+
+        return VaultResourceWithStreamingResponse(self._client.vault)
+
+    @cached_property
+    def voice(self) -> voice.VoiceResourceWithStreamingResponse:
+        from .resources.voice import VoiceResourceWithStreamingResponse
+
+        return VoiceResourceWithStreamingResponse(self._client.voice)
 
 
 class AsyncCasedevWithStreamedResponse:
+    _client: AsyncCasedev
+
     def __init__(self, client: AsyncCasedev) -> None:
-        self.actions = actions.AsyncActionsResourceWithStreamingResponse(client.actions)
-        self.compute = compute.AsyncComputeResourceWithStreamingResponse(client.compute)
-        self.convert = convert.AsyncConvertResourceWithStreamingResponse(client.convert)
-        self.format = format.AsyncFormatResourceWithStreamingResponse(client.format)
-        self.llm = llm.AsyncLlmResourceWithStreamingResponse(client.llm)
-        self.ocr = ocr.AsyncOcrResourceWithStreamingResponse(client.ocr)
-        self.search = search.AsyncSearchResourceWithStreamingResponse(client.search)
-        self.vault = vault.AsyncVaultResourceWithStreamingResponse(client.vault)
-        self.voice = voice.AsyncVoiceResourceWithStreamingResponse(client.voice)
-        self.webhooks = webhooks.AsyncWebhooksResourceWithStreamingResponse(client.webhooks)
-        self.templates = templates.AsyncTemplatesResourceWithStreamingResponse(client.templates)
-        self.workflows = workflows.AsyncWorkflowsResourceWithStreamingResponse(client.workflows)
+        self._client = client
+
+    @cached_property
+    def compute(self) -> compute.AsyncComputeResourceWithStreamingResponse:
+        from .resources.compute import AsyncComputeResourceWithStreamingResponse
+
+        return AsyncComputeResourceWithStreamingResponse(self._client.compute)
+
+    @cached_property
+    def format(self) -> format.AsyncFormatResourceWithStreamingResponse:
+        from .resources.format import AsyncFormatResourceWithStreamingResponse
+
+        return AsyncFormatResourceWithStreamingResponse(self._client.format)
+
+    @cached_property
+    def llm(self) -> llm.AsyncLlmResourceWithStreamingResponse:
+        from .resources.llm import AsyncLlmResourceWithStreamingResponse
+
+        return AsyncLlmResourceWithStreamingResponse(self._client.llm)
+
+    @cached_property
+    def ocr(self) -> ocr.AsyncOcrResourceWithStreamingResponse:
+        from .resources.ocr import AsyncOcrResourceWithStreamingResponse
+
+        return AsyncOcrResourceWithStreamingResponse(self._client.ocr)
+
+    @cached_property
+    def search(self) -> search.AsyncSearchResourceWithStreamingResponse:
+        from .resources.search import AsyncSearchResourceWithStreamingResponse
+
+        return AsyncSearchResourceWithStreamingResponse(self._client.search)
+
+    @cached_property
+    def vault(self) -> vault.AsyncVaultResourceWithStreamingResponse:
+        from .resources.vault import AsyncVaultResourceWithStreamingResponse
+
+        return AsyncVaultResourceWithStreamingResponse(self._client.vault)
+
+    @cached_property
+    def voice(self) -> voice.AsyncVoiceResourceWithStreamingResponse:
+        from .resources.voice import AsyncVoiceResourceWithStreamingResponse
+
+        return AsyncVoiceResourceWithStreamingResponse(self._client.voice)
 
 
 Client = Casedev

casedev/_models.py

@@ -3,7 +3,20 @@ from __future__ import annotations
 import os
 import inspect
 import weakref
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Type,
+    Union,
+    Generic,
+    TypeVar,
+    Callable,
+    Iterable,
+    Optional,
+    AsyncIterable,
+    cast,
+)
 from datetime import date, datetime
 from typing_extensions import (
     List,
@@ -787,6 +800,7 @@ class FinalRequestOptionsInput(TypedDict, total=False):
     timeout: float | Timeout | None
     files: HttpxRequestFiles | None
     idempotency_key: str
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None]
     json_data: Body
     extra_json: AnyMapping
     follow_redirects: bool
@@ -805,6 +819,7 @@ class FinalRequestOptions(pydantic.BaseModel):
     post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven()
     follow_redirects: Union[bool, None] = None
 
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None] = None
     # It should be noted that we cannot use `json` here as that would override
     # a BaseModel method in an incompatible fashion.
     json_data: Union[Body, None] = None

casedev/_types.py

@@ -13,9 +13,11 @@ from typing import (
     Mapping,
     TypeVar,
     Callable,
+    Iterable,
     Iterator,
     Optional,
     Sequence,
+    AsyncIterable,
 )
 from typing_extensions import (
     Set,
@@ -56,6 +58,13 @@ if TYPE_CHECKING:
 else:
     Base64FileInput = Union[IO[bytes], PathLike]
     FileContent = Union[IO[bytes], bytes, PathLike]  # PathLike is not subscriptable in Python 3.8.
+
+
+# Used for sending raw binary data / streaming data in request bodies
+# e.g. for file uploads without multipart encoding
+BinaryTypes = Union[bytes, bytearray, IO[bytes], Iterable[bytes]]
+AsyncBinaryTypes = Union[bytes, bytearray, IO[bytes], AsyncIterable[bytes]]
+
 FileTypes = Union[
     # file (or bytes)
     FileContent,
@@ -243,6 +252,9 @@ _T_co = TypeVar("_T_co", covariant=True)
 if TYPE_CHECKING:
     # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
     # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    #
+    # Note: index() and count() methods are intentionally omitted to allow pyright to properly
+    # infer TypedDict types when dict literals are used in lists assigned to SequenceNotStr.
     class SequenceNotStr(Protocol[_T_co]):
         @overload
         def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
@@ -251,8 +263,6 @@ if TYPE_CHECKING:
         def __contains__(self, value: object, /) -> bool: ...
         def __len__(self) -> int: ...
         def __iter__(self) -> Iterator[_T_co]: ...
-        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
-        def count(self, value: Any, /) -> int: ...
         def __reversed__(self) -> Iterator[_T_co]: ...
 else:
     # just point this to a normal `Sequence` at runtime to avoid having to special case

casedev/_version.py

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

casedev/resources/__init__.py

@@ -48,14 +48,6 @@ from .search import (
     SearchResourceWithStreamingResponse,
     AsyncSearchResourceWithStreamingResponse,
 )
-from .actions import (
-    ActionsResource,
-    AsyncActionsResource,
-    ActionsResourceWithRawResponse,
-    AsyncActionsResourceWithRawResponse,
-    ActionsResourceWithStreamingResponse,
-    AsyncActionsResourceWithStreamingResponse,
-)
 from .compute import (
     ComputeResource,
     AsyncComputeResource,
@@ -64,58 +56,14 @@ from .compute import (
     ComputeResourceWithStreamingResponse,
     AsyncComputeResourceWithStreamingResponse,
 )
-from .convert import (
-    ConvertResource,
-    AsyncConvertResource,
-    ConvertResourceWithRawResponse,
-    AsyncConvertResourceWithRawResponse,
-    ConvertResourceWithStreamingResponse,
-    AsyncConvertResourceWithStreamingResponse,
-)
-from .webhooks import (
-    WebhooksResource,
-    AsyncWebhooksResource,
-    WebhooksResourceWithRawResponse,
-    AsyncWebhooksResourceWithRawResponse,
-    WebhooksResourceWithStreamingResponse,
-    AsyncWebhooksResourceWithStreamingResponse,
-)
-from .templates import (
-    TemplatesResource,
-    AsyncTemplatesResource,
-    TemplatesResourceWithRawResponse,
-    AsyncTemplatesResourceWithRawResponse,
-    TemplatesResourceWithStreamingResponse,
-    AsyncTemplatesResourceWithStreamingResponse,
-)
-from .workflows import (
-    WorkflowsResource,
-    AsyncWorkflowsResource,
-    WorkflowsResourceWithRawResponse,
-    AsyncWorkflowsResourceWithRawResponse,
-    WorkflowsResourceWithStreamingResponse,
-    AsyncWorkflowsResourceWithStreamingResponse,
-)
 
 __all__ = [
-    "ActionsResource",
-    "AsyncActionsResource",
-    "ActionsResourceWithRawResponse",
-    "AsyncActionsResourceWithRawResponse",
-    "ActionsResourceWithStreamingResponse",
-    "AsyncActionsResourceWithStreamingResponse",
     "ComputeResource",
     "AsyncComputeResource",
     "ComputeResourceWithRawResponse",
     "AsyncComputeResourceWithRawResponse",
     "ComputeResourceWithStreamingResponse",
     "AsyncComputeResourceWithStreamingResponse",
-    "ConvertResource",
-    "AsyncConvertResource",
-    "ConvertResourceWithRawResponse",
-    "AsyncConvertResourceWithRawResponse",
-    "ConvertResourceWithStreamingResponse",
-    "AsyncConvertResourceWithStreamingResponse",
     "FormatResource",
     "AsyncFormatResource",
     "FormatResourceWithRawResponse",
@@ -152,22 +100,4 @@ __all__ = [
     "AsyncVoiceResourceWithRawResponse",
     "VoiceResourceWithStreamingResponse",
     "AsyncVoiceResourceWithStreamingResponse",
-    "WebhooksResource",
-    "AsyncWebhooksResource",
-    "WebhooksResourceWithRawResponse",
-    "AsyncWebhooksResourceWithRawResponse",
-    "WebhooksResourceWithStreamingResponse",
-    "AsyncWebhooksResourceWithStreamingResponse",
-    "TemplatesResource",
-    "AsyncTemplatesResource",
-    "TemplatesResourceWithRawResponse",
-    "AsyncTemplatesResourceWithRawResponse",
-    "TemplatesResourceWithStreamingResponse",
-    "AsyncTemplatesResourceWithStreamingResponse",
-    "WorkflowsResource",
-    "AsyncWorkflowsResource",
-    "WorkflowsResourceWithRawResponse",
-    "AsyncWorkflowsResourceWithRawResponse",
-    "WorkflowsResourceWithStreamingResponse",
-    "AsyncWorkflowsResourceWithStreamingResponse",
 ]