casedev 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

casedev/resources/compute/v1/instances.py

@@ -0,0 +1,448 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, 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.compute.v1 import instance_create_params
+from ....types.compute.v1.instance_list_response import InstanceListResponse
+from ....types.compute.v1.instance_create_response import InstanceCreateResponse
+from ....types.compute.v1.instance_delete_response import InstanceDeleteResponse
+from ....types.compute.v1.instance_retrieve_response import InstanceRetrieveResponse
+
+__all__ = ["InstancesResource", "AsyncInstancesResource"]
+
+
+class InstancesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> InstancesResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return InstancesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> InstancesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return InstancesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        instance_type: str,
+        name: str,
+        region: str,
+        auto_shutdown_minutes: Optional[int] | Omit = omit,
+        vault_ids: SequenceNotStr[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,
+    ) -> InstanceCreateResponse:
+        """Launches a new GPU compute instance with automatic SSH key generation.
+
+        Supports
+        mounting Case.dev Vaults as filesystems and configurable auto-shutdown. Instance
+        boots in ~2-5 minutes. Perfect for batch OCR processing, AI model training, and
+        intensive document analysis workloads.
+
+        Args:
+          instance_type: GPU type (e.g., 'gpu_1x_h100_sxm5')
+
+          name: Instance name
+
+          region: Region (e.g., 'us-west-1')
+
+          auto_shutdown_minutes: Auto-shutdown timer (null = never)
+
+          vault_ids: Vault IDs to mount
+
+          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(
+            "/compute/v1/instances",
+            body=maybe_transform(
+                {
+                    "instance_type": instance_type,
+                    "name": name,
+                    "region": region,
+                    "auto_shutdown_minutes": auto_shutdown_minutes,
+                    "vault_ids": vault_ids,
+                },
+                instance_create_params.InstanceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        id: 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,
+    ) -> InstanceRetrieveResponse:
+        """
+        Retrieves detailed information about a GPU instance including SSH connection
+        details, vault mount scripts, real-time cost tracking, and current status. SSH
+        private key included for secure access.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            f"/compute/v1/instances/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceRetrieveResponse,
+        )
+
+    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,
+    ) -> InstanceListResponse:
+        """
+        Retrieves all GPU compute instances for your organization with real-time status
+        updates from Lambda Labs. Includes pricing, runtime metrics, and auto-shutdown
+        configuration. Perfect for monitoring AI workloads, document processing jobs,
+        and cost tracking.
+        """
+        return self._get(
+            "/compute/v1/instances",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceListResponse,
+        )
+
+    def delete(
+        self,
+        id: 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,
+    ) -> InstanceDeleteResponse:
+        """Terminates a running GPU instance, calculates final cost, and cleans up SSH
+        keys.
+
+        This action is permanent and cannot be undone. All data on the instance
+        will be lost.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._delete(
+            f"/compute/v1/instances/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceDeleteResponse,
+        )
+
+
+class AsyncInstancesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncInstancesResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncInstancesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncInstancesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncInstancesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        instance_type: str,
+        name: str,
+        region: str,
+        auto_shutdown_minutes: Optional[int] | Omit = omit,
+        vault_ids: SequenceNotStr[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,
+    ) -> InstanceCreateResponse:
+        """Launches a new GPU compute instance with automatic SSH key generation.
+
+        Supports
+        mounting Case.dev Vaults as filesystems and configurable auto-shutdown. Instance
+        boots in ~2-5 minutes. Perfect for batch OCR processing, AI model training, and
+        intensive document analysis workloads.
+
+        Args:
+          instance_type: GPU type (e.g., 'gpu_1x_h100_sxm5')
+
+          name: Instance name
+
+          region: Region (e.g., 'us-west-1')
+
+          auto_shutdown_minutes: Auto-shutdown timer (null = never)
+
+          vault_ids: Vault IDs to mount
+
+          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(
+            "/compute/v1/instances",
+            body=await async_maybe_transform(
+                {
+                    "instance_type": instance_type,
+                    "name": name,
+                    "region": region,
+                    "auto_shutdown_minutes": auto_shutdown_minutes,
+                    "vault_ids": vault_ids,
+                },
+                instance_create_params.InstanceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        id: 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,
+    ) -> InstanceRetrieveResponse:
+        """
+        Retrieves detailed information about a GPU instance including SSH connection
+        details, vault mount scripts, real-time cost tracking, and current status. SSH
+        private key included for secure access.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            f"/compute/v1/instances/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceRetrieveResponse,
+        )
+
+    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,
+    ) -> InstanceListResponse:
+        """
+        Retrieves all GPU compute instances for your organization with real-time status
+        updates from Lambda Labs. Includes pricing, runtime metrics, and auto-shutdown
+        configuration. Perfect for monitoring AI workloads, document processing jobs,
+        and cost tracking.
+        """
+        return await self._get(
+            "/compute/v1/instances",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceListResponse,
+        )
+
+    async def delete(
+        self,
+        id: 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,
+    ) -> InstanceDeleteResponse:
+        """Terminates a running GPU instance, calculates final cost, and cleans up SSH
+        keys.
+
+        This action is permanent and cannot be undone. All data on the instance
+        will be lost.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._delete(
+            f"/compute/v1/instances/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceDeleteResponse,
+        )
+
+
+class InstancesResourceWithRawResponse:
+    def __init__(self, instances: InstancesResource) -> None:
+        self._instances = instances
+
+        self.create = to_raw_response_wrapper(
+            instances.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            instances.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            instances.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            instances.delete,
+        )
+
+
+class AsyncInstancesResourceWithRawResponse:
+    def __init__(self, instances: AsyncInstancesResource) -> None:
+        self._instances = instances
+
+        self.create = async_to_raw_response_wrapper(
+            instances.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            instances.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            instances.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            instances.delete,
+        )
+
+
+class InstancesResourceWithStreamingResponse:
+    def __init__(self, instances: InstancesResource) -> None:
+        self._instances = instances
+
+        self.create = to_streamed_response_wrapper(
+            instances.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            instances.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            instances.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            instances.delete,
+        )
+
+
+class AsyncInstancesResourceWithStreamingResponse:
+    def __init__(self, instances: AsyncInstancesResource) -> None:
+        self._instances = instances
+
+        self.create = async_to_streamed_response_wrapper(
+            instances.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            instances.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            instances.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            instances.delete,
+        )

casedev/resources/compute/v1/v1.py

@@ -14,6 +14,14 @@ from .secrets import (
 )
 from ...._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
 from ...._utils import maybe_transform, async_maybe_transform
+from .instances import (
+    InstancesResource,
+    AsyncInstancesResource,
+    InstancesResourceWithRawResponse,
+    AsyncInstancesResourceWithRawResponse,
+    InstancesResourceWithStreamingResponse,
+    AsyncInstancesResourceWithStreamingResponse,
+)
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import (
@@ -30,6 +38,14 @@ from .environments import (
     EnvironmentsResourceWithStreamingResponse,
     AsyncEnvironmentsResourceWithStreamingResponse,
 )
+from .instance_types import (
+    InstanceTypesResource,
+    AsyncInstanceTypesResource,
+    InstanceTypesResourceWithRawResponse,
+    AsyncInstanceTypesResourceWithRawResponse,
+    InstanceTypesResourceWithStreamingResponse,
+    AsyncInstanceTypesResourceWithStreamingResponse,
+)
 from ...._base_client import make_request_options
 from ....types.compute import v1_get_usage_params
 from ....types.compute.v1_get_usage_response import V1GetUsageResponse
@@ -42,6 +58,14 @@ class V1Resource(SyncAPIResource):
     def environments(self) -> EnvironmentsResource:
         return EnvironmentsResource(self._client)
 
+    @cached_property
+    def instance_types(self) -> InstanceTypesResource:
+        return InstanceTypesResource(self._client)
+
+    @cached_property
+    def instances(self) -> InstancesResource:
+        return InstancesResource(self._client)
+
     @cached_property
     def secrets(self) -> SecretsResource:
         return SecretsResource(self._client)
@@ -144,6 +168,14 @@ class AsyncV1Resource(AsyncAPIResource):
     def environments(self) -> AsyncEnvironmentsResource:
         return AsyncEnvironmentsResource(self._client)
 
+    @cached_property
+    def instance_types(self) -> AsyncInstanceTypesResource:
+        return AsyncInstanceTypesResource(self._client)
+
+    @cached_property
+    def instances(self) -> AsyncInstancesResource:
+        return AsyncInstancesResource(self._client)
+
     @cached_property
     def secrets(self) -> AsyncSecretsResource:
         return AsyncSecretsResource(self._client)
@@ -256,6 +288,14 @@ class V1ResourceWithRawResponse:
     def environments(self) -> EnvironmentsResourceWithRawResponse:
         return EnvironmentsResourceWithRawResponse(self._v1.environments)
 
+    @cached_property
+    def instance_types(self) -> InstanceTypesResourceWithRawResponse:
+        return InstanceTypesResourceWithRawResponse(self._v1.instance_types)
+
+    @cached_property
+    def instances(self) -> InstancesResourceWithRawResponse:
+        return InstancesResourceWithRawResponse(self._v1.instances)
+
     @cached_property
     def secrets(self) -> SecretsResourceWithRawResponse:
         return SecretsResourceWithRawResponse(self._v1.secrets)
@@ -276,6 +316,14 @@ class AsyncV1ResourceWithRawResponse:
     def environments(self) -> AsyncEnvironmentsResourceWithRawResponse:
         return AsyncEnvironmentsResourceWithRawResponse(self._v1.environments)
 
+    @cached_property
+    def instance_types(self) -> AsyncInstanceTypesResourceWithRawResponse:
+        return AsyncInstanceTypesResourceWithRawResponse(self._v1.instance_types)
+
+    @cached_property
+    def instances(self) -> AsyncInstancesResourceWithRawResponse:
+        return AsyncInstancesResourceWithRawResponse(self._v1.instances)
+
     @cached_property
     def secrets(self) -> AsyncSecretsResourceWithRawResponse:
         return AsyncSecretsResourceWithRawResponse(self._v1.secrets)
@@ -296,6 +344,14 @@ class V1ResourceWithStreamingResponse:
     def environments(self) -> EnvironmentsResourceWithStreamingResponse:
         return EnvironmentsResourceWithStreamingResponse(self._v1.environments)
 
+    @cached_property
+    def instance_types(self) -> InstanceTypesResourceWithStreamingResponse:
+        return InstanceTypesResourceWithStreamingResponse(self._v1.instance_types)
+
+    @cached_property
+    def instances(self) -> InstancesResourceWithStreamingResponse:
+        return InstancesResourceWithStreamingResponse(self._v1.instances)
+
     @cached_property
     def secrets(self) -> SecretsResourceWithStreamingResponse:
         return SecretsResourceWithStreamingResponse(self._v1.secrets)
@@ -316,6 +372,14 @@ class AsyncV1ResourceWithStreamingResponse:
     def environments(self) -> AsyncEnvironmentsResourceWithStreamingResponse:
         return AsyncEnvironmentsResourceWithStreamingResponse(self._v1.environments)
 
+    @cached_property
+    def instance_types(self) -> AsyncInstanceTypesResourceWithStreamingResponse:
+        return AsyncInstanceTypesResourceWithStreamingResponse(self._v1.instance_types)
+
+    @cached_property
+    def instances(self) -> AsyncInstancesResourceWithStreamingResponse:
+        return AsyncInstancesResourceWithStreamingResponse(self._v1.instances)
+
     @cached_property
     def secrets(self) -> AsyncSecretsResourceWithStreamingResponse:
         return AsyncSecretsResourceWithStreamingResponse(self._v1.secrets)

casedev/resources/database/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from .database import (
+    DatabaseResource,
+    AsyncDatabaseResource,
+    DatabaseResourceWithRawResponse,
+    AsyncDatabaseResourceWithRawResponse,
+    DatabaseResourceWithStreamingResponse,
+    AsyncDatabaseResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "V1Resource",
+    "AsyncV1Resource",
+    "V1ResourceWithRawResponse",
+    "AsyncV1ResourceWithRawResponse",
+    "V1ResourceWithStreamingResponse",
+    "AsyncV1ResourceWithStreamingResponse",
+    "DatabaseResource",
+    "AsyncDatabaseResource",
+    "DatabaseResourceWithRawResponse",
+    "AsyncDatabaseResourceWithRawResponse",
+    "DatabaseResourceWithStreamingResponse",
+    "AsyncDatabaseResourceWithStreamingResponse",
+]

casedev/resources/database/database.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .v1.v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["DatabaseResource", "AsyncDatabaseResource"]
+
+
+class DatabaseResource(SyncAPIResource):
+    @cached_property
+    def v1(self) -> V1Resource:
+        return V1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> DatabaseResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return DatabaseResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DatabaseResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return DatabaseResourceWithStreamingResponse(self)
+
+
+class AsyncDatabaseResource(AsyncAPIResource):
+    @cached_property
+    def v1(self) -> AsyncV1Resource:
+        return AsyncV1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncDatabaseResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncDatabaseResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDatabaseResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncDatabaseResourceWithStreamingResponse(self)
+
+
+class DatabaseResourceWithRawResponse:
+    def __init__(self, database: DatabaseResource) -> None:
+        self._database = database
+
+    @cached_property
+    def v1(self) -> V1ResourceWithRawResponse:
+        return V1ResourceWithRawResponse(self._database.v1)
+
+
+class AsyncDatabaseResourceWithRawResponse:
+    def __init__(self, database: AsyncDatabaseResource) -> None:
+        self._database = database
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithRawResponse:
+        return AsyncV1ResourceWithRawResponse(self._database.v1)
+
+
+class DatabaseResourceWithStreamingResponse:
+    def __init__(self, database: DatabaseResource) -> None:
+        self._database = database
+
+    @cached_property
+    def v1(self) -> V1ResourceWithStreamingResponse:
+        return V1ResourceWithStreamingResponse(self._database.v1)
+
+
+class AsyncDatabaseResourceWithStreamingResponse:
+    def __init__(self, database: AsyncDatabaseResource) -> None:
+        self._database = database
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithStreamingResponse:
+        return AsyncV1ResourceWithStreamingResponse(self._database.v1)