volcano-sdk-python 0.6.7__py3-none-any.whl

volcano_sdk/_transport.py

@@ -0,0 +1,1767 @@
+"""Internal transport boundary around the generated OpenAPI client."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from io import BytesIO
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, Any, Protocol, cast
+from uuid import UUID, uuid4
+
+import httpx
+
+from ._generated.api.authentication import (
+    auth_confirm_email_change,
+    auth_convert_anonymous,
+    auth_get_user,
+    auth_logout,
+    auth_refresh,
+    auth_signin,
+    auth_signup,
+    auth_update_user,
+)
+from ._generated.api.authentication.auth_cancel_email_change import (
+    _get_kwargs as cancel_email_change_kwargs,
+)
+from ._generated.api.authentication.auth_confirm_email import (
+    _get_kwargs as confirm_email_kwargs,
+)
+from ._generated.api.authentication.auth_delete_all_my_sessions import (
+    _get_kwargs as delete_all_my_sessions_kwargs,
+)
+from ._generated.api.authentication.auth_delete_my_session import (
+    _get_kwargs as delete_my_session_kwargs,
+)
+from ._generated.api.authentication.auth_forgot_password import (
+    _get_kwargs as forgot_password_kwargs,
+)
+from ._generated.api.authentication.auth_get_my_sessions import (
+    _get_kwargs as get_my_sessions_kwargs,
+)
+from ._generated.api.authentication.auth_request_email_change import (
+    _get_kwargs as request_email_change_kwargs,
+)
+from ._generated.api.authentication.auth_resend_confirmation import (
+    _get_kwargs as resend_confirmation_kwargs,
+)
+from ._generated.api.authentication.auth_reset_password import (
+    _get_kwargs as reset_password_kwargs,
+)
+from ._generated.api.authentication.auth_signup_anonymous import (
+    _get_kwargs as signup_anonymous_kwargs,
+)
+from ._generated.api.database_queries import (
+    query_database_select,
+)
+from ._generated.api.database_queries.query_database_delete import (
+    _build_response as build_database_delete_response,
+)
+from ._generated.api.database_queries.query_database_delete import (
+    _get_kwargs as database_delete_kwargs,
+)
+from ._generated.api.database_queries.query_database_insert import (
+    _build_response as build_database_insert_response,
+)
+from ._generated.api.database_queries.query_database_insert import (
+    _get_kwargs as database_insert_kwargs,
+)
+from ._generated.api.database_queries.query_database_select import (
+    _build_response as build_database_select_response,
+)
+from ._generated.api.database_queries.query_database_select import (
+    _get_kwargs as database_select_kwargs,
+)
+from ._generated.api.database_queries.query_database_update import (
+    _build_response as build_database_update_response,
+)
+from ._generated.api.database_queries.query_database_update import (
+    _get_kwargs as database_update_kwargs,
+)
+from ._generated.api.functions import resolve_function_for_invocation
+from ._generated.api.functions.invoke_function import (
+    _get_kwargs as invoke_function_kwargs,
+)
+from ._generated.api.locks import (
+    acquire_project_lock,
+    force_release_project_lock,
+    get_project_lock,
+    release_project_lock,
+    renew_project_lock,
+)
+from ._generated.api.logs.get_project_log_activity import (
+    _build_response as build_log_activity_response,
+)
+from ._generated.api.logs.get_project_log_activity import (
+    _get_kwargs as log_activity_kwargs,
+)
+from ._generated.api.logs.search_project_logs import (
+    _build_response as build_log_search_response,
+)
+from ._generated.api.logs.search_project_logs import (
+    _get_kwargs as log_search_kwargs,
+)
+from ._generated.api.o_auth_authentication import auth_o_auth_exchange
+from ._generated.api.o_auth_authentication.auth_link_o_auth_provider import (
+    _get_kwargs as link_oauth_provider_kwargs,
+)
+from ._generated.api.o_auth_authentication.auth_list_o_auth_providers import (
+    _get_kwargs as list_oauth_providers_kwargs,
+)
+from ._generated.api.o_auth_authentication.auth_o_auth_authorize import (
+    _get_kwargs as oauth_authorize_kwargs,
+)
+from ._generated.api.o_auth_authentication.auth_unlink_o_auth_provider import (
+    _get_kwargs as unlink_oauth_provider_kwargs,
+)
+from ._generated.api.o_auth_authentication.call_o_auth_provider_api import (
+    _get_kwargs as call_oauth_provider_api_kwargs,
+)
+from ._generated.api.o_auth_authentication.get_o_auth_provider_token import (
+    _get_kwargs as get_oauth_provider_token_kwargs,
+)
+from ._generated.api.o_auth_authentication.refresh_o_auth_provider_token import (
+    _get_kwargs as refresh_oauth_provider_token_kwargs,
+)
+from ._generated.api.storage_objects import (
+    copy_storage_object,
+    delete_storage_object,
+    download_storage_object,
+    list_storage_objects,
+    move_storage_object,
+    update_storage_object_visibility,
+    upload_part,
+    upload_storage_object,
+)
+from ._generated.client import AuthenticatedClient
+from ._generated.models.auth_confirm_email_body import AuthConfirmEmailBody
+from ._generated.models.auth_confirm_email_change_body import AuthConfirmEmailChangeBody
+from ._generated.models.auth_convert_anonymous_body import AuthConvertAnonymousBody
+from ._generated.models.auth_convert_anonymous_body_user_metadata import (
+    AuthConvertAnonymousBodyUserMetadata,
+)
+from ._generated.models.auth_forgot_password_body import AuthForgotPasswordBody
+from ._generated.models.auth_get_my_sessions_response_200 import (
+    AuthGetMySessionsResponse200,
+)
+from ._generated.models.auth_link_o_auth_provider_response_200 import (
+    AuthLinkOAuthProviderResponse200,
+)
+from ._generated.models.auth_list_o_auth_providers_response_200 import (
+    AuthListOAuthProvidersResponse200,
+)
+from ._generated.models.auth_logout_body import AuthLogoutBody
+from ._generated.models.auth_o_auth_exchange_body import AuthOAuthExchangeBody
+from ._generated.models.auth_refresh_body import AuthRefreshBody
+from ._generated.models.auth_request_email_change_body import AuthRequestEmailChangeBody
+from ._generated.models.auth_resend_confirmation_body import AuthResendConfirmationBody
+from ._generated.models.auth_reset_password_body import AuthResetPasswordBody
+from ._generated.models.auth_signin_body import AuthSigninBody
+from ._generated.models.auth_signup_anonymous_body import AuthSignupAnonymousBody
+from ._generated.models.auth_signup_anonymous_body_user_metadata import (
+    AuthSignupAnonymousBodyUserMetadata,
+)
+from ._generated.models.auth_signup_body import AuthSignupBody
+from ._generated.models.auth_signup_body_user_metadata import (
+    AuthSignupBodyUserMetadata,
+)
+from ._generated.models.auth_update_user_body import AuthUpdateUserBody
+from ._generated.models.auth_update_user_body_user_metadata import (
+    AuthUpdateUserBodyUserMetadata,
+)
+from ._generated.models.call_o_auth_provider_api_body import CallOAuthProviderAPIBody
+from ._generated.models.call_o_auth_provider_api_response_200 import (
+    CallOAuthProviderAPIResponse200,
+)
+from ._generated.models.create_upload_session_request import CreateUploadSessionRequest
+from ._generated.models.database_delete_request import DatabaseDeleteRequest
+from ._generated.models.database_insert_request import DatabaseInsertRequest
+from ._generated.models.database_select_request import DatabaseSelectRequest
+from ._generated.models.database_update_request import DatabaseUpdateRequest
+from ._generated.models.function_invocation_request import FunctionInvocationRequest
+from ._generated.models.function_invocation_request_payload import (
+    FunctionInvocationRequestPayload,
+)
+from ._generated.models.get_o_auth_provider_token_response_200 import (
+    GetOAuthProviderTokenResponse200,
+)
+from ._generated.models.log_activity_request import LogActivityRequest
+from ._generated.models.log_search_request import LogSearchRequest
+from ._generated.models.project_lock_lease_request import ProjectLockLeaseRequest
+from ._generated.models.refresh_o_auth_provider_token_response_200 import (
+    RefreshOAuthProviderTokenResponse200,
+)
+from ._generated.models.storage_copy_request import StorageCopyRequest
+from ._generated.models.storage_move_request import StorageMoveRequest
+from ._generated.models.storage_visibility_request import StorageVisibilityRequest
+from ._generated.models.upload_storage_object_files_body import (
+    UploadStorageObjectFilesBody,
+)
+from ._generated.types import UNSET, File
+from .errors import (
+    AuthenticationError,
+    ConflictError,
+    NotFoundError,
+    RateLimitedError,
+    ServerError,
+    TransportError,
+    ValidationError,
+    VolcanoError,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from ._generated.models.auth_link_o_auth_provider_provider import (
+        AuthLinkOAuthProviderProvider,
+    )
+    from ._generated.models.auth_o_auth_authorize_provider import (
+        AuthOAuthAuthorizeProvider,
+    )
+    from ._generated.models.auth_unlink_o_auth_provider_provider import (
+        AuthUnlinkOAuthProviderProvider,
+    )
+    from ._generated.models.call_o_auth_provider_api_provider import (
+        CallOAuthProviderAPIProvider,
+    )
+    from ._generated.models.get_o_auth_provider_token_provider import (
+        GetOAuthProviderTokenProvider,
+    )
+    from ._generated.models.refresh_o_auth_provider_token_provider import (
+        RefreshOAuthProviderTokenProvider,
+    )
+    from .models import JSONValue
+
+HTTP_UNAUTHORIZED = 401
+HTTP_NOT_FOUND = 404
+HTTP_CONFLICT = 409
+HTTP_RATE_LIMITED = 429
+HTTP_OK = 200
+HTTP_SERVER_ERROR_MIN = 500
+HTTP_SERVER_ERROR_MAX = 599
+_MALFORMED_USER_PROFILE = "Expected a complete user profile"
+_MALFORMED_SESSION_PAGE = "Expected a complete session page"
+_MALFORMED_LINKED_OAUTH_PROVIDERS = "Expected complete linked OAuth providers"
+_MALFORMED_OAUTH_LINK = "Expected an OAuth authorization URL"
+_MALFORMED_OAUTH_STATUS = "Expected complete OAuth provider token status"
+_MALFORMED_OAUTH_API_RESPONSE = "Expected OAuth provider API response data"
+ERROR_TYPES_BY_STATUS: dict[int, type[VolcanoError]] = {
+    400: ValidationError,
+    401: AuthenticationError,
+    403: AuthenticationError,
+    HTTP_NOT_FOUND: NotFoundError,
+    HTTP_CONFLICT: ConflictError,
+    422: ValidationError,
+    HTTP_RATE_LIMITED: RateLimitedError,
+}
+
+
+def _plain_json(value: JSONValue) -> JSONValue:
+    if isinstance(value, Mapping):
+        return {key: _plain_json(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_plain_json(item) for item in value]
+    return value
+
+
+class TransportResponse(Protocol):
+    @property
+    def status_code(self) -> int: ...
+
+    @property
+    def payload(self) -> Any: ...
+
+    @property
+    def content(self) -> bytes: ...
+
+    @property
+    def headers(self) -> Mapping[str, str] | None: ...
+
+
+class _RawHTTPResponse(Protocol):
+    @property
+    def status_code(self) -> int: ...
+
+    @property
+    def content(self) -> bytes: ...
+
+    @property
+    def headers(self) -> Mapping[str, str]: ...
+
+
+@dataclass(frozen=True, slots=True)
+class StorageUploadSessionRequest:
+    """Values needed to create a resumable storage upload session."""
+
+    path: str
+    content_type: str
+    total_size: int
+    part_size: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class StorageUploadPartRequest:
+    """Values needed to upload one resumable storage part."""
+
+    path: str
+    session_id: str
+    part_number: int
+    data: bytes
+
+
+@dataclass(frozen=True, slots=True)
+class StorageUploadSessionReference:
+    """Values identifying one resumable storage upload session."""
+
+    path: str
+    session_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class _GeneratedTransportResponse:
+    status_code: int
+    payload: Any
+    content: bytes
+    headers: Mapping[str, str]
+
+
+class AuthRefreshTransport(Protocol):
+    def auth_refresh(
+        self,
+        *,
+        authorization: str,
+        refresh_token: str,
+    ) -> TransportResponse: ...
+
+
+class AuthLogoutTransport(Protocol):
+    def auth_logout(
+        self,
+        *,
+        authorization: str,
+        refresh_token: str,
+    ) -> TransportResponse: ...
+
+
+class AuthSignUpTransport(Protocol):
+    def auth_signup(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse: ...
+
+
+class AuthSignUpAnonymousTransport(Protocol):
+    def auth_signup_anonymous(
+        self,
+        *,
+        authorization: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse: ...
+
+
+class AuthConvertAnonymousTransport(Protocol):
+    def auth_convert_anonymous(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse: ...
+
+
+class AuthForgotPasswordTransport(Protocol):
+    def auth_forgot_password(
+        self,
+        *,
+        authorization: str,
+        email: str,
+    ) -> TransportResponse: ...
+
+
+class AuthConfirmEmailTransport(Protocol):
+    def auth_confirm_email(
+        self,
+        *,
+        authorization: str,
+        token: str,
+    ) -> TransportResponse: ...
+
+
+class AuthResetPasswordTransport(Protocol):
+    def auth_reset_password(
+        self,
+        *,
+        authorization: str,
+        token: str,
+        new_password: str,
+    ) -> TransportResponse: ...
+
+
+class AuthResendConfirmationTransport(Protocol):
+    def auth_resend_confirmation(
+        self,
+        *,
+        authorization: str,
+        email: str,
+    ) -> TransportResponse: ...
+
+
+class AuthRequestEmailChangeTransport(Protocol):
+    def auth_request_email_change(
+        self,
+        *,
+        authorization: str,
+        new_email: str,
+    ) -> TransportResponse: ...
+
+
+class AuthCancelEmailChangeTransport(Protocol):
+    def auth_cancel_email_change(
+        self,
+        *,
+        authorization: str,
+    ) -> TransportResponse: ...
+
+
+class AuthConfirmEmailChangeTransport(Protocol):
+    def auth_confirm_email_change(
+        self,
+        *,
+        authorization: str,
+        token: str,
+    ) -> TransportResponse: ...
+
+
+class AuthDeleteAllMySessionsTransport(Protocol):
+    def auth_delete_all_my_sessions(
+        self,
+        *,
+        authorization: str,
+    ) -> TransportResponse: ...
+
+
+class AuthDeleteMySessionTransport(Protocol):
+    def auth_delete_my_session(
+        self,
+        *,
+        authorization: str,
+        session_id: str,
+    ) -> TransportResponse: ...
+
+
+class AuthGetMySessionsTransport(Protocol):
+    def auth_get_my_sessions(
+        self,
+        *,
+        authorization: str,
+        page: int,
+        limit: int,
+    ) -> TransportResponse: ...
+
+
+class AuthListOAuthProvidersTransport(Protocol):
+    def auth_list_oauth_providers(
+        self,
+        *,
+        authorization: str,
+    ) -> TransportResponse: ...
+
+
+class AuthOAuthAuthorizationURLTransport(Protocol):
+    def auth_oauth_authorization_url(
+        self,
+        *,
+        anon_key: str,
+        provider: AuthOAuthAuthorizeProvider,
+        redirect_url: str,
+        client_state: str,
+    ) -> str: ...
+
+
+class AuthOAuthExchangeTransport(Protocol):
+    def auth_oauth_exchange(
+        self,
+        *,
+        authorization: str,
+        code: str,
+        redirect_url: str,
+    ) -> TransportResponse: ...
+
+
+class AuthLinkOAuthProviderTransport(Protocol):
+    def auth_link_oauth_provider(
+        self,
+        *,
+        authorization: str,
+        provider: AuthLinkOAuthProviderProvider,
+    ) -> TransportResponse: ...
+
+
+class AuthUnlinkOAuthProviderTransport(Protocol):
+    def auth_unlink_oauth_provider(
+        self,
+        *,
+        authorization: str,
+        provider: AuthUnlinkOAuthProviderProvider,
+    ) -> TransportResponse: ...
+
+
+class AuthGetOAuthProviderTokenTransport(Protocol):
+    def auth_get_oauth_provider_token(
+        self,
+        *,
+        authorization: str,
+        provider: GetOAuthProviderTokenProvider,
+    ) -> TransportResponse: ...
+
+
+class AuthRefreshOAuthProviderTokenTransport(Protocol):
+    def auth_refresh_oauth_provider_token(
+        self,
+        *,
+        authorization: str,
+        provider: RefreshOAuthProviderTokenProvider,
+    ) -> TransportResponse: ...
+
+
+class AuthCallOAuthAPITransport(Protocol):
+    def auth_call_oauth_api(
+        self,
+        *,
+        authorization: str,
+        provider: CallOAuthProviderAPIProvider,
+        endpoint: str,
+        method: str,
+        body: Mapping[str, Any] | None,
+    ) -> TransportResponse: ...
+
+
+class AuthGetUserTransport(Protocol):
+    def auth_get_user(self, *, authorization: str) -> TransportResponse: ...
+
+
+class AuthUpdateUserTransport(Protocol):
+    def auth_update_user(
+        self,
+        *,
+        authorization: str,
+        password: str | None,
+        metadata: dict[str, object] | None,
+    ) -> TransportResponse: ...
+
+
+class Transport(Protocol):
+    def auth_signin(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+    ) -> TransportResponse: ...
+
+    def query_database_select(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse: ...
+
+    def query_database_insert(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse: ...
+
+    def query_database_update(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse: ...
+
+    def query_database_delete(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse: ...
+
+    def upload_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+        data: bytes,
+        content_type: str = "application/octet-stream",
+    ) -> TransportResponse: ...
+
+    def download_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+        byte_range: str | None = None,
+    ) -> TransportResponse: ...
+
+    def acquire_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+        ttl: int,
+        token: str,
+    ) -> TransportResponse: ...
+
+    def release_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+        token: str,
+    ) -> TransportResponse: ...
+
+
+class AsyncDatabaseSelectTransport(Protocol):
+    """Async database query capability used by cancellable realtime fetches."""
+
+    async def query_database_select_async(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse: ...
+
+
+def invoke(operation: Callable[..., Any], **kwargs: Any) -> Any:
+    try:
+        return operation(**kwargs)
+    except httpx.HTTPError as error:
+        raise TransportError(str(error) or "Volcano transport failed") from error
+
+
+async def invoke_async(
+    operation: Callable[..., Awaitable[Any]],
+    **kwargs: Any,
+) -> Any:
+    try:
+        return await operation(**kwargs)
+    except httpx.HTTPError as error:
+        raise TransportError(str(error) or "Volcano transport failed") from error
+
+
+def _header(headers: Mapping[str, str] | None, name: str) -> str | None:
+    if headers is None:
+        return None
+    for key, value in headers.items():
+        if key.lower() == name.lower():
+            return value
+    return None
+
+
+def _error_type(status: int) -> type[VolcanoError]:
+    error_type = ERROR_TYPES_BY_STATUS.get(status)
+    if error_type is not None:
+        return error_type
+    if HTTP_SERVER_ERROR_MIN <= status <= HTTP_SERVER_ERROR_MAX:
+        return ServerError
+    return VolcanoError
+
+
+def response_payload(response: Any, expected_status: int) -> Any:
+    status = int(response.status_code)
+    if status != expected_status:
+        payload: Mapping[str, object]
+        raw_payload = response.payload
+        if isinstance(raw_payload, dict):
+            payload = cast("Mapping[str, object]", raw_payload)
+        else:
+            payload = {}
+        message = str(
+            payload.get("error") or payload.get("message") or "Volcano request failed"
+        )
+        code_value = payload.get("code")
+        code = str(code_value) if code_value is not None else None
+        retry_after = None
+        if status == HTTP_RATE_LIMITED:
+            retry_after_value = _header(response.headers, "Retry-After")
+            try:
+                retry_after = (
+                    int(retry_after_value) if retry_after_value is not None else None
+                )
+            except ValueError:
+                retry_after = None
+        raise _error_type(status)(
+            message,
+            status=status,
+            code=code,
+            retry_after=retry_after,
+        )
+    return response.payload
+
+
+class GeneratedTransport:
+    def __init__(
+        self,
+        *,
+        api_url: str,
+        timeout: float = 60.0,
+        httpx_transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._api_url = api_url.rstrip("/")
+        self._timeout = timeout
+        self._httpx_transport = httpx_transport
+
+    def _client(self, authorization: str) -> AuthenticatedClient:
+        httpx_args: dict[str, Any] = {}
+        if self._httpx_transport is not None:
+            httpx_args["transport"] = self._httpx_transport
+        return AuthenticatedClient(
+            base_url=self._api_url,
+            token=authorization,
+            timeout=httpx.Timeout(self._timeout),
+            httpx_args=httpx_args,
+        )
+
+    @staticmethod
+    def _response(response: Any) -> TransportResponse:
+        parsed = response.parsed
+        if hasattr(parsed, "to_dict"):
+            payload = parsed.to_dict()
+        elif parsed is not None:
+            payload = parsed
+        else:
+            try:
+                payload = json.loads(response.content)
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                payload = None
+        return _GeneratedTransportResponse(
+            status_code=int(response.status_code),
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    @staticmethod
+    def _raw_response(response: _RawHTTPResponse) -> TransportResponse:
+        try:
+            payload = json.loads(response.content)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            payload = None
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_signin(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = auth_signin.sync_detailed(
+                client=client,
+                body=AuthSigninBody(email=email, password=password),
+            )
+        return self._response(response)
+
+    def auth_signup(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse:
+        body = AuthSignupBody(
+            email=email,
+            password=password,
+            user_metadata=AuthSignupBodyUserMetadata.from_dict(metadata),
+        )
+        with self._client(authorization) as client:
+            response = auth_signup.sync_detailed(client=client, body=body)
+        return self._response(response)
+
+    def auth_signup_anonymous(
+        self,
+        *,
+        authorization: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse:
+        body = AuthSignupAnonymousBody(
+            user_metadata=AuthSignupAnonymousBodyUserMetadata.from_dict(metadata)
+        )
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **signup_anonymous_kwargs(body=body)
+            )
+        return self._raw_response(response)
+
+    def auth_convert_anonymous(
+        self,
+        *,
+        authorization: str,
+        email: str,
+        password: str,
+        metadata: dict[str, object],
+    ) -> TransportResponse:
+        body = AuthConvertAnonymousBody(
+            email=email,
+            password=password,
+            user_metadata=AuthConvertAnonymousBodyUserMetadata.from_dict(metadata),
+        )
+        try:
+            with self._client(authorization) as client:
+                response = auth_convert_anonymous.sync_detailed(
+                    client=client,
+                    body=body,
+                )
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise AuthenticationError(_MALFORMED_USER_PROFILE) from error
+        if int(response.status_code) != HTTP_OK:
+            return self._response(response)
+        return _GeneratedTransportResponse(
+            status_code=int(response.status_code),
+            payload=response.parsed,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_forgot_password(
+        self,
+        *,
+        authorization: str,
+        email: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **forgot_password_kwargs(body=AuthForgotPasswordBody(email=email))
+            )
+        return self._raw_response(response)
+
+    def auth_confirm_email(
+        self,
+        *,
+        authorization: str,
+        token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **confirm_email_kwargs(body=AuthConfirmEmailBody(token=token))
+            )
+        return self._raw_response(response)
+
+    def auth_reset_password(
+        self,
+        *,
+        authorization: str,
+        token: str,
+        new_password: str,
+    ) -> TransportResponse:
+        body = AuthResetPasswordBody(token=token, new_password=new_password)
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **reset_password_kwargs(body=body)
+            )
+        return self._raw_response(response)
+
+    def auth_resend_confirmation(
+        self,
+        *,
+        authorization: str,
+        email: str,
+    ) -> TransportResponse:
+        body = AuthResendConfirmationBody(email=email)
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **resend_confirmation_kwargs(body=body)
+            )
+        return self._raw_response(response)
+
+    def auth_request_email_change(
+        self,
+        *,
+        authorization: str,
+        new_email: str,
+    ) -> TransportResponse:
+        body = AuthRequestEmailChangeBody(new_email=new_email)
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **request_email_change_kwargs(body=body)
+            )
+        return self._raw_response(response)
+
+    def auth_cancel_email_change(self, *, authorization: str) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(**cancel_email_change_kwargs())
+        return self._raw_response(response)
+
+    def auth_confirm_email_change(
+        self,
+        *,
+        authorization: str,
+        token: str,
+    ) -> TransportResponse:
+        body = AuthConfirmEmailChangeBody(email_change_token=token)
+        try:
+            with self._client(authorization) as client:
+                response = auth_confirm_email_change.sync_detailed(
+                    client=client,
+                    body=body,
+                )
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise AuthenticationError(_MALFORMED_USER_PROFILE) from error
+        if int(response.status_code) != HTTP_OK:
+            return self._response(response)
+        return _GeneratedTransportResponse(
+            status_code=int(response.status_code),
+            payload=response.parsed,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_delete_all_my_sessions(
+        self,
+        *,
+        authorization: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **delete_all_my_sessions_kwargs()
+            )
+        return self._raw_response(response)
+
+    def auth_delete_my_session(
+        self,
+        *,
+        authorization: str,
+        session_id: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **delete_my_session_kwargs(session_id=cast("UUID", session_id))
+            )
+        return self._raw_response(response)
+
+    def auth_get_my_sessions(
+        self,
+        *,
+        authorization: str,
+        page: int,
+        limit: int,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **get_my_sessions_kwargs(page=page, limit=limit)
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = AuthGetMySessionsResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_SESSION_PAGE) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_list_oauth_providers(
+        self,
+        *,
+        authorization: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **list_oauth_providers_kwargs()
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = AuthListOAuthProvidersResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_LINKED_OAUTH_PROVIDERS) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_oauth_authorization_url(
+        self,
+        *,
+        anon_key: str,
+        provider: AuthOAuthAuthorizeProvider,
+        redirect_url: str,
+        client_state: str,
+    ) -> str:
+        request = oauth_authorize_kwargs(
+            provider,
+            anon_key=anon_key,
+            redirect_url=redirect_url,
+            client_state=client_state,
+            response_mode="code",
+        )
+        return str(
+            httpx.URL(
+                f"{self._api_url}{request['url']}",
+                params=request["params"],
+            )
+        )
+
+    def auth_oauth_exchange(
+        self,
+        *,
+        authorization: str,
+        code: str,
+        redirect_url: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = auth_o_auth_exchange.sync_detailed(
+                client=client,
+                body=AuthOAuthExchangeBody(code=code, redirect_url=redirect_url),
+            )
+        return self._response(response)
+
+    def auth_link_oauth_provider(
+        self,
+        *,
+        authorization: str,
+        provider: AuthLinkOAuthProviderProvider,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **link_oauth_provider_kwargs(provider)
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = AuthLinkOAuthProviderResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_OAUTH_LINK) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_unlink_oauth_provider(
+        self,
+        *,
+        authorization: str,
+        provider: AuthUnlinkOAuthProviderProvider,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **unlink_oauth_provider_kwargs(provider)
+            )
+        return self._raw_response(response)
+
+    def auth_get_oauth_provider_token(
+        self,
+        *,
+        authorization: str,
+        provider: GetOAuthProviderTokenProvider,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **get_oauth_provider_token_kwargs(provider)
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = GetOAuthProviderTokenResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_OAUTH_STATUS) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_refresh_oauth_provider_token(
+        self,
+        *,
+        authorization: str,
+        provider: RefreshOAuthProviderTokenProvider,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **refresh_oauth_provider_token_kwargs(provider)
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = RefreshOAuthProviderTokenResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_OAUTH_STATUS) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_call_oauth_api(
+        self,
+        *,
+        authorization: str,
+        provider: CallOAuthProviderAPIProvider,
+        endpoint: str,
+        method: str,
+        body: Mapping[str, Any] | None,
+    ) -> TransportResponse:
+        request_values: dict[str, Any] = {"endpoint": endpoint, "method": method}
+        if body is not None:
+            request_values["body"] = _plain_json(body)
+        request_body = CallOAuthProviderAPIBody.from_dict(request_values)
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **call_oauth_provider_api_kwargs(provider, body=request_body)
+            )
+        if response.status_code != HTTP_OK:
+            return self._raw_response(response)
+        try:
+            payload = CallOAuthProviderAPIResponse200.from_dict(response.json())
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise VolcanoError(_MALFORMED_OAUTH_API_RESPONSE) from error
+        return _GeneratedTransportResponse(
+            status_code=response.status_code,
+            payload=payload,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_get_user(self, *, authorization: str) -> TransportResponse:
+        try:
+            with self._client(authorization) as client:
+                response = auth_get_user.sync_detailed(client=client)
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise AuthenticationError(_MALFORMED_USER_PROFILE) from error
+        if int(response.status_code) != HTTP_OK:
+            return self._response(response)
+        return _GeneratedTransportResponse(
+            status_code=int(response.status_code),
+            payload=response.parsed,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_update_user(
+        self,
+        *,
+        authorization: str,
+        password: str | None,
+        metadata: dict[str, object] | None,
+    ) -> TransportResponse:
+        body = AuthUpdateUserBody(
+            password=UNSET if password is None else password,
+            user_metadata=(
+                UNSET
+                if metadata is None
+                else AuthUpdateUserBodyUserMetadata.from_dict(metadata)
+            ),
+        )
+        try:
+            with self._client(authorization) as client:
+                response = auth_update_user.sync_detailed(client=client, body=body)
+        except (
+            AttributeError,
+            KeyError,
+            TypeError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as error:
+            raise AuthenticationError(_MALFORMED_USER_PROFILE) from error
+        if int(response.status_code) != HTTP_OK:
+            return self._response(response)
+        return _GeneratedTransportResponse(
+            status_code=int(response.status_code),
+            payload=response.parsed,
+            content=response.content,
+            headers=dict(response.headers),
+        )
+
+    def auth_refresh(
+        self,
+        *,
+        authorization: str,
+        refresh_token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = auth_refresh.sync_detailed(
+                client=client,
+                body=AuthRefreshBody(refresh_token=refresh_token),
+            )
+        return self._response(response)
+
+    def auth_logout(
+        self,
+        *,
+        authorization: str,
+        refresh_token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = auth_logout.sync_detailed(
+                client=client,
+                body=AuthLogoutBody(refresh_token=refresh_token),
+            )
+        return self._response(response)
+
+    def query_database_select(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **database_select_kwargs(
+                    database_name,
+                    body=DatabaseSelectRequest.from_dict(body),
+                )
+            )
+            if response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(response)
+            parsed = build_database_select_response(client=client, response=response)
+        return self._response(parsed)
+
+    async def query_database_select_async(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse:
+        async with self._client(authorization) as client:
+            response = await query_database_select.asyncio_detailed(
+                database_name,
+                client=client,
+                body=DatabaseSelectRequest.from_dict(body),
+            )
+        return self._response(response)
+
+    def query_database_insert(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **database_insert_kwargs(
+                    database_name, body=DatabaseInsertRequest.from_dict(body)
+                )
+            )
+            if response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(response)
+            parsed = build_database_insert_response(client=client, response=response)
+        return self._response(parsed)
+
+    def query_database_update(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **database_update_kwargs(
+                    database_name, body=DatabaseUpdateRequest.from_dict(body)
+                )
+            )
+            if response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(response)
+            parsed = build_database_update_response(client=client, response=response)
+        return self._response(parsed)
+
+    def query_database_delete(
+        self,
+        *,
+        authorization: str,
+        database_name: str,
+        body: dict[str, Any],
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **database_delete_kwargs(
+                    database_name, body=DatabaseDeleteRequest.from_dict(body)
+                )
+            )
+            if response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(response)
+            parsed = build_database_delete_response(client=client, response=response)
+        return self._response(parsed)
+
+    def upload_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+        data: bytes,
+        content_type: str = "application/octet-stream",
+    ) -> TransportResponse:
+        file_name = PurePosixPath(path).name or "file"
+        body = UploadStorageObjectFilesBody(
+            file=File(
+                payload=BytesIO(data),
+                file_name=file_name,
+                mime_type=content_type,
+            )
+        )
+        with self._client(authorization) as client:
+            response = upload_storage_object.sync_detailed(
+                bucket_name,
+                path,
+                client=client,
+                body=body,
+            )
+        return self._response(response)
+
+    def create_upload_session(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        request: StorageUploadSessionRequest,
+    ) -> TransportResponse:
+        body = CreateUploadSessionRequest(
+            object_path=request.path,
+            content_type=request.content_type,
+            total_size=request.total_size,
+            part_size=request.part_size if request.part_size is not None else UNSET,
+        )
+        with self._client(authorization) as client:
+            response = upload_storage_object.sync_detailed(
+                bucket_name,
+                request.path,
+                client=client,
+                body=body,
+            )
+        return self._response(response)
+
+    def upload_part(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        request: StorageUploadPartRequest,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = upload_part.sync_detailed(
+                bucket_name,
+                request.path,
+                client=client,
+                body=File(payload=BytesIO(request.data)),
+                x_upload_session=request.session_id,
+                x_part_number=request.part_number,
+            )
+        return self._response(response)
+
+    def complete_upload_session(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        request: StorageUploadSessionReference,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = upload_storage_object.sync_detailed(
+                bucket_name,
+                request.path,
+                client=client,
+                x_upload_session=request.session_id,
+                x_upload_complete="true",
+            )
+        return self._response(response)
+
+    def get_upload_session(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        request: StorageUploadSessionReference,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = download_storage_object.sync_detailed(
+                bucket_name,
+                request.path,
+                client=client,
+                x_upload_session=request.session_id,
+            )
+        return self._raw_response(response)
+
+    def abort_upload_session(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        request: StorageUploadSessionReference,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = delete_storage_object.sync_detailed(
+                bucket_name,
+                request.path,
+                client=client,
+                x_upload_session=request.session_id,
+            )
+        return self._response(response)
+
+    def download_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+        byte_range: str | None = None,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = download_storage_object.sync_detailed(
+                bucket_name,
+                path,
+                client=client,
+                range_=byte_range if byte_range is not None else UNSET,
+            )
+        return self._response(response)
+
+    def list_storage_objects(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        prefix: str,
+        limit: int | None,
+        cursor: str | None,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = list_storage_objects.sync_detailed(
+                bucket_name,
+                client=client,
+                prefix=prefix or UNSET,
+                limit=limit if limit is not None else UNSET,
+                cursor=cursor if cursor is not None else UNSET,
+            )
+        return self._response(response)
+
+    def delete_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = delete_storage_object.sync_detailed(
+                bucket_name,
+                path,
+                client=client,
+            )
+        return self._response(response)
+
+    def move_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        from_path: str,
+        to_path: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = move_storage_object.sync_detailed(
+                bucket_name,
+                client=client,
+                body=StorageMoveRequest(from_=from_path, to=to_path),
+            )
+        return self._response(response)
+
+    def copy_storage_object(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        from_path: str,
+        to_path: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = copy_storage_object.sync_detailed(
+                bucket_name,
+                client=client,
+                body=StorageCopyRequest(from_=from_path, to=to_path),
+            )
+        return self._response(response)
+
+    def update_storage_object_visibility(
+        self,
+        *,
+        authorization: str,
+        bucket_name: str,
+        path: str,
+        is_public: bool,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = update_storage_object_visibility.sync_detailed(
+                bucket_name,
+                path,
+                client=client,
+                body=StorageVisibilityRequest(is_public=is_public),
+            )
+        return self._response(response)
+
+    def resolve_function_for_invocation(
+        self,
+        *,
+        authorization: str,
+        name: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = resolve_function_for_invocation.sync_detailed(
+                client=client,
+                name=name,
+            )
+        return self._response(response)
+
+    def invoke_function(
+        self,
+        *,
+        authorization: str,
+        function_id: str,
+        payload: Mapping[str, JSONValue],
+    ) -> TransportResponse:
+        plain_payload = cast("dict[str, JSONValue]", _plain_json(payload))
+        body = FunctionInvocationRequest(
+            payload=FunctionInvocationRequestPayload.from_dict(plain_payload)
+        )
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                **invoke_function_kwargs(
+                    UUID(function_id),
+                    body=body,
+                )
+            )
+        return self._raw_response(response)
+
+    def invoke_function_url(
+        self,
+        *,
+        authorization: str,
+        invoke_url: str,
+        payload: Mapping[str, JSONValue],
+    ) -> TransportResponse:
+        # The resolved endpoint is absolute and off the API host, so it cannot
+        # go through the generated client's base URL. The body still uses the
+        # invoke contract's { payload } envelope.
+        plain_payload = cast("dict[str, JSONValue]", _plain_json(payload))
+        with self._client(authorization) as client:
+            response = client.get_httpx_client().request(
+                method="POST",
+                url=invoke_url,
+                json={"payload": plain_payload},
+                headers={
+                    "Authorization": f"Bearer {authorization}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._raw_response(response)
+
+    def search_project_logs(
+        self,
+        *,
+        authorization: str,
+        project_id: str,
+        request: Mapping[str, JSONValue],
+    ) -> TransportResponse:
+        plain_request = cast("dict[str, Any]", _plain_json(request))
+        with self._client(authorization) as client:
+            request_kwargs = log_search_kwargs(
+                UUID(project_id), body=LogSearchRequest.from_dict(plain_request)
+            )
+            request_kwargs["json"] = plain_request
+            raw_response = client.get_httpx_client().request(**request_kwargs)
+            if raw_response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(raw_response)
+            response = build_log_search_response(
+                client=client,
+                response=raw_response,
+            )
+        return self._response(response)
+
+    def get_project_log_activity(
+        self,
+        *,
+        authorization: str,
+        project_id: str,
+        request: Mapping[str, JSONValue],
+    ) -> TransportResponse:
+        plain_request = cast("dict[str, Any]", _plain_json(request))
+        with self._client(authorization) as client:
+            request_kwargs = log_activity_kwargs(
+                UUID(project_id), body=LogActivityRequest.from_dict(plain_request)
+            )
+            request_kwargs["json"] = plain_request
+            raw_response = client.get_httpx_client().request(**request_kwargs)
+            if raw_response.status_code == HTTP_UNAUTHORIZED:
+                return self._raw_response(raw_response)
+            response = build_log_activity_response(
+                client=client,
+                response=raw_response,
+            )
+        return self._response(response)
+
+    def acquire_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+        ttl: int,
+        token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = acquire_project_lock.sync_detailed(
+                key,
+                client=client,
+                body=ProjectLockLeaseRequest(ttl_seconds=ttl),
+                x_volcano_lock_token=cast("UUID", token),
+                x_volcano_request_id=cast("UUID", str(uuid4())),
+            )
+        return self._response(response)
+
+    def get_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = get_project_lock.sync_detailed(
+                key,
+                client=client,
+                x_volcano_request_id=cast("UUID", str(uuid4())),
+            )
+        return self._response(response)
+
+    def force_release_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = force_release_project_lock.sync_detailed(
+                key,
+                client=client,
+                x_volcano_request_id=cast("UUID", str(uuid4())),
+            )
+        return self._response(response)
+
+    def renew_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+        ttl: int,
+        token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = renew_project_lock.sync_detailed(
+                key,
+                client=client,
+                body=ProjectLockLeaseRequest(ttl_seconds=ttl),
+                x_volcano_lock_token=cast("UUID", token),
+                x_volcano_request_id=cast("UUID", str(uuid4())),
+            )
+        return self._response(response)
+
+    def release_project_lock(
+        self,
+        *,
+        authorization: str,
+        key: str,
+        token: str,
+    ) -> TransportResponse:
+        with self._client(authorization) as client:
+            response = release_project_lock.sync_detailed(
+                key,
+                client=client,
+                x_volcano_lock_token=cast("UUID", token),
+                x_volcano_request_id=cast("UUID", str(uuid4())),
+            )
+        return self._response(response)