capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/_services/code_catalyst.py

@@ -0,0 +1,212 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#CodeCatalyst``."""
+
+import warnings
+from typing import TYPE_CHECKING, Any, Iterable, Optional
+
+from typing_extensions import Self, TypedDict
+from zapros import BaseHandler, Client
+
+import capo_codecatalyst._auth._signers
+import capo_codecatalyst._auth._sigv4
+from capo_codecatalyst._auth._providers import (
+    BearerTokenProvider,
+    StaticBearerTokenProvider,
+)
+from capo_codecatalyst._auth._zapros_handler import AuthMiddleware
+from capo_codecatalyst._resources.code_catalyst.access_token import AccessToken
+from capo_codecatalyst._resources.code_catalyst.space import Space
+from capo_codecatalyst._services._aws_config import aws_config
+from capo_codecatalyst._services._pipeline import (
+    Interceptor,
+    OperationOptions,
+    OperationRequest,
+    OperationResponse,
+    execute_pipeline,
+    retry,
+)
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.get_user_details_request
+    import capo_codecatalyst.types.get_user_details_response
+    import capo_codecatalyst.types.verify_session_response
+
+
+class CodeCatalystClientConfig(TypedDict, total=False, closed=True):
+    operation_interceptors: Iterable[Interceptor[Any, Any]]
+    retry_max_attempts: int | None
+    use_fips: bool | None
+    region: str | None
+    endpoint: str | None
+    bearer_provider: BearerTokenProvider | None
+
+
+class CodeCatalystClient:
+    """A client for the ``CodeCatalyst`` service.
+
+    Args:
+        http_handler: HTTP handler for sending requests. If not provided, creates a default handler.
+        operation_interceptors: Interceptors that wrap every operation call. If not provided, defaults to an empty list.
+        retry_max_attempts: Maximum number of times to retry a failed operation. Defaults to 3.
+        use_fips: The value of the ``AWS::UseFIPS`` endpoint parameter.
+        region: The value of the ``AWS::Region`` endpoint parameter.
+        endpoint: The value of the ``SDK::Endpoint`` endpoint parameter.
+        bearer: Bearer token for authentication.
+        bearer_provider: Provider that resolves bearer tokens. Takes precedence over ``bearer``.
+    """
+
+    def __init__(
+        self,
+        http_handler: BaseHandler | None = None,
+        operation_interceptors: Iterable[Interceptor[Any, Any]] | None = None,
+        retry_max_attempts: int | None = None,
+        use_fips: bool | None = None,
+        region: str | None = None,
+        endpoint: str | None = None,
+        bearer: str | None = None,
+        bearer_provider: BearerTokenProvider | None = None,
+    ):
+        self._client = Client(http_handler).wrap_with_middleware(
+            lambda next: AuthMiddleware(next)
+        )
+        if bearer is not None and bearer_provider is not None:
+            warnings.warn(
+                "Both bearer and bearer_provider given; provider takes precedence"
+            )
+        if bearer_provider is None and bearer is not None:
+            bearer_provider = StaticBearerTokenProvider(bearer)
+        self._config = CodeCatalystClientConfig(
+            {
+                "operation_interceptors": operation_interceptors or [],
+                "retry_max_attempts": retry_max_attempts,
+                "use_fips": use_fips,
+                "region": region,
+                "endpoint": endpoint,
+                "bearer_provider": bearer_provider,
+            }
+        )
+
+        # resources
+        self.access_token = AccessToken(self)
+        self.space = Space(self)
+
+    def operation_options(
+        self, config_overrides: Optional[CodeCatalystClientConfig] = None
+    ) -> tuple[Iterable[Interceptor[Any, Any]], OperationOptions]:
+        overrides: CodeCatalystClientConfig = config_overrides or {}
+        interceptors_: list[Interceptor[Any, Any]] = [
+            *overrides.get(
+                "operation_interceptors", self._config.get("operation_interceptors", [])
+            ),
+            aws_config(),
+            retry(),
+        ]
+        options_: OperationOptions = OperationOptions(
+            client=self._client,
+            retry_max_attempts=overrides.get(
+                "retry_max_attempts", self._config.get("retry_max_attempts")
+            ),
+            use_fips=overrides.get("use_fips", self._config.get("use_fips")),
+            region=overrides.get("region", self._config.get("region")),
+            endpoint=overrides.get("endpoint", self._config.get("endpoint")),
+            bearer_provider=overrides.get(
+                "bearer_provider", self._config.get("bearer_provider")
+            ),
+        )
+        return interceptors_, options_
+
+    def get_user_details(
+        self,
+        *,
+        config_overrides: Optional[CodeCatalystClientConfig] = None,
+        id: Optional[str] = None,
+        user_name: Optional[str] = None,
+    ) -> "capo_codecatalyst.types.get_user_details_response.GetUserDetailsResponse":
+        """<p>Returns information about a user. </p>
+
+        Args:
+            id: <p>The system-generated unique ID of the user. </p>
+            user_name: <p>The name of the user as displayed in Amazon CodeCatalyst.</p>
+
+        Raises:
+            capo_codecatalyst.errors.access_denied_exception.AccessDeniedException: <p>The request was denied because you don't have sufficient access to perform this action. Verify that you are a member of a role that allows this action.</p>
+            capo_codecatalyst.errors.conflict_exception.ConflictException: <p>The request was denied because the requested operation would cause a conflict with the current state of a service resource associated with the request. Another user might have updated the resource. Reload, make sure you have the latest data, and then try again.</p>
+            capo_codecatalyst.errors.resource_not_found_exception.ResourceNotFoundException: <p>The request was denied because the specified resource was not found. Verify that the spelling is correct and that you have access to the resource.</p>
+            capo_codecatalyst.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request was denied because one or more resources has reached its limits for the tier the space belongs to. Either reduce the number of resources, or change the tier if applicable.</p>
+            capo_codecatalyst.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
+            capo_codecatalyst.errors.validation_exception.ValidationException: <p>The request was denied because an input failed to satisfy the constraints specified by the service. Check the spelling and input requirements, and then try again.</p>
+            capo_codecatalyst.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[capo_codecatalyst.types.get_user_details_request.GetUserDetailsRequest]",
+        ) -> OperationResponse[
+            "capo_codecatalyst.types.get_user_details_response.GetUserDetailsResponse"
+        ]:
+            import capo_codecatalyst._operations.code_catalyst.get_user_details
+
+            output, http_response = (
+                capo_codecatalyst._operations.code_catalyst.get_user_details.get_user_details(
+                    req.options, req.input
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+        input_: capo_codecatalyst.types.get_user_details_request.GetUserDetailsRequest = {}
+        if id is not None:
+            input_["id"] = id
+        if user_name is not None:
+            input_["user_name"] = user_name
+
+        response = execute_pipeline(
+            OperationRequest(input=input_, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def verify_session(
+        self, *, config_overrides: Optional[CodeCatalystClientConfig] = None
+    ) -> "capo_codecatalyst.types.verify_session_response.VerifySessionResponse":
+        """<p>Verifies whether the calling user has a valid Amazon CodeCatalyst login and session. If successful, this returns the ID of the user in Amazon CodeCatalyst.</p>
+
+        Raises:
+            capo_codecatalyst.errors.access_denied_exception.AccessDeniedException: <p>The request was denied because you don't have sufficient access to perform this action. Verify that you are a member of a role that allows this action.</p>
+            capo_codecatalyst.errors.conflict_exception.ConflictException: <p>The request was denied because the requested operation would cause a conflict with the current state of a service resource associated with the request. Another user might have updated the resource. Reload, make sure you have the latest data, and then try again.</p>
+            capo_codecatalyst.errors.resource_not_found_exception.ResourceNotFoundException: <p>The request was denied because the specified resource was not found. Verify that the spelling is correct and that you have access to the resource.</p>
+            capo_codecatalyst.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request was denied because one or more resources has reached its limits for the tier the space belongs to. Either reduce the number of resources, or change the tier if applicable.</p>
+            capo_codecatalyst.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
+            capo_codecatalyst.errors.validation_exception.ValidationException: <p>The request was denied because an input failed to satisfy the constraints specified by the service. Check the spelling and input requirements, and then try again.</p>
+            capo_codecatalyst.errors.UnknownServiceError: The service returned an error code this client does not model.
+        """
+
+        def _handler(
+            req: "OperationRequest[None]",
+        ) -> OperationResponse[
+            "capo_codecatalyst.types.verify_session_response.VerifySessionResponse"
+        ]:
+            import capo_codecatalyst._operations.code_catalyst.verify_session
+
+            output, http_response = (
+                capo_codecatalyst._operations.code_catalyst.verify_session.verify_session(
+                    req.options
+                )
+            )
+            return OperationResponse(output=output, response=http_response)
+
+        interceptors_, options_ = self.operation_options(config_overrides)
+
+        response = execute_pipeline(
+            OperationRequest(input=None, options=options_),
+            handler=_handler,
+            interceptors=list(interceptors_),
+        )
+        response.response.close()
+        return response.output
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any):
+        self._client.close()

capo_codecatalyst/errors/__init__.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from ._base import (
+    CodeCatalystError as CodeCatalystError,
+)
+from ._base import (
+    DeserializationError as DeserializationError,
+)
+from ._base import (
+    SerializationError as SerializationError,
+)
+from ._base import (
+    ServiceError as ServiceError,
+)
+from ._base import (
+    UnknownServiceError as UnknownServiceError,
+)
+from ._base import (
+    WaiterFailedError as WaiterFailedError,
+)
+from ._base import (
+    WaiterTimeoutError as WaiterTimeoutError,
+)
+from .access_denied_exception import AccessDeniedException as AccessDeniedException
+from .conflict_exception import ConflictException as ConflictException
+from .resource_not_found_exception import (
+    ResourceNotFoundException as ResourceNotFoundException,
+)
+from .service_quota_exceeded_exception import (
+    ServiceQuotaExceededException as ServiceQuotaExceededException,
+)
+from .throttling_exception import ThrottlingException as ThrottlingException
+from .validation_exception import ValidationException as ValidationException

capo_codecatalyst/errors/_base.py

@@ -0,0 +1,94 @@
+from typing import Literal
+
+
+class CodeCatalystError(Exception):
+    """Base class for all CodeCatalyst service errors."""
+
+
+class ServiceError(CodeCatalystError):
+    """Base class for all modeled service errors.
+
+    Args:
+        fault: ``"client"`` or ``"server"``.
+        is_throttling_error: Whether this error is a throttling error.
+        is_retryable: Whether this error is retryable.
+        code: The wire error code, or ``None``.
+        message: The error message, or ``None``.
+    """
+
+    code: str | None = None
+
+    def __init__(
+        self,
+        fault: Literal["client", "server"],
+        *,
+        is_throttling_error: bool,
+        is_retryable: bool,
+        code: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        super().__init__(f"{code or '<no code>'}: {message or '<no message>'}")
+        self.fault = fault
+        self.is_throttling_error = is_throttling_error
+        self.is_retryable = is_retryable
+        self.code = code
+        self.message = message
+
+
+class SerializationError(CodeCatalystError):
+    """Raised when a value cannot be serialized."""
+
+
+class DeserializationError(CodeCatalystError):
+    """Raised when a value cannot be deserialized or a required member is missing."""
+
+
+class UnknownServiceError(ServiceError):
+    """Raised when the server returns an error code the client does not model.
+
+    Args:
+        code: ``<Code>`` text from the response body, or ``None`` if absent.
+        message: ``<Message>`` text from the response body, or ``None``.
+        response: The original HTTP response object, for arbitrary inspection.
+    """
+
+    def __init__(
+        self, *, code: str | None, message: str | None, response: object
+    ) -> None:
+        _status = getattr(response, "status", 500)
+        _fault: Literal["client", "server"] = "client" if _status < 500 else "server"
+        _throttling = _status == 429
+        _retryable = _throttling or _status >= 500
+        super().__init__(
+            _fault,
+            is_throttling_error=_throttling,
+            is_retryable=_retryable,
+            code=code,
+            message=message,
+        )
+        self.response = response
+
+
+class WaiterFailedError(CodeCatalystError):
+    """Raised when a waiter hits an acceptor with ``state="failure"``.
+
+    Args:
+        waiter_name: snake_case waiter name (e.g. ``bucket_exists``).
+        reason: Short description of which acceptor fired.
+    """
+
+    def __init__(self, waiter_name: str, reason: str) -> None:
+        super().__init__(f"waiter {waiter_name} failed: {reason}")
+        self.waiter_name = waiter_name
+        self.reason = reason
+
+
+class WaiterTimeoutError(CodeCatalystError):
+    """Raised when a waiter exhausts ``max_wait_time`` without a terminal acceptor."""
+
+    def __init__(self, waiter_name: str, max_wait_time: float) -> None:
+        super().__init__(
+            f"waiter {waiter_name} timed out after {max_wait_time} seconds"
+        )
+        self.waiter_name = waiter_name
+        self.max_wait_time = max_wait_time

capo_codecatalyst/errors/access_denied_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#AccessDeniedException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class AccessDeniedException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccessDeniedException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> AccessDeniedException_:
+    out: AccessDeniedException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("AccessDeniedException_.message required")
+    return out
+
+
+class AccessDeniedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#AccessDeniedException``."""
+
+    code: str | None = "AccessDeniedException"
+
+    def __init__(self, data: AccessDeniedException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="AccessDeniedException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "AccessDeniedException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/errors/conflict_exception.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ConflictException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class ConflictException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ConflictException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ConflictException_:
+    out: ConflictException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ConflictException_.message required")
+    return out
+
+
+class ConflictException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#ConflictException``."""
+
+    code: str | None = "ConflictException"
+
+    def __init__(self, data: ConflictException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ConflictException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ConflictException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/errors/resource_not_found_exception.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ResourceNotFoundException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class ResourceNotFoundException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceNotFoundException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ResourceNotFoundException_:
+    out: ResourceNotFoundException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ResourceNotFoundException_.message required")
+    return out
+
+
+class ResourceNotFoundException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#ResourceNotFoundException``."""
+
+    code: str | None = "ResourceNotFoundException"
+
+    def __init__(self, data: ResourceNotFoundException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ResourceNotFoundException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceNotFoundException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/errors/service_quota_exceeded_exception.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ServiceQuotaExceededException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class ServiceQuotaExceededException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceQuotaExceededException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceQuotaExceededException_:
+    out: ServiceQuotaExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ServiceQuotaExceededException_.message required")
+    return out
+
+
+class ServiceQuotaExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#ServiceQuotaExceededException``."""
+
+    code: str | None = "ServiceQuotaExceededException"
+
+    def __init__(
+        self, data: ServiceQuotaExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ServiceQuotaExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ServiceQuotaExceededException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/errors/throttling_exception.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ThrottlingException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class ThrottlingException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ThrottlingException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ThrottlingException_:
+    out: ThrottlingException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ThrottlingException_.message required")
+    return out
+
+
+class ThrottlingException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#ThrottlingException``."""
+
+    code: str | None = "ThrottlingException"
+
+    def __init__(self, data: ThrottlingException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=True,
+            code="ThrottlingException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ThrottlingException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/errors/validation_exception.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ValidationException``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError, ServiceError
+
+
+class ValidationException_(TypedDict, closed=True):
+    message: "str"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ValidationException_) -> dict:
+    out: dict = {}
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ValidationException_:
+    out: ValidationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("ValidationException_.message required")
+    return out
+
+
+class ValidationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codecatalyst#ValidationException``."""
+
+    code: str | None = "ValidationException"
+
+    def __init__(self, data: ValidationException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ValidationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict, message: str | None = None) -> "ValidationException":
+        return cls(deserialize_json(data), message)

capo_codecatalyst/types/_prelude/blob.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Blob``."""
+
+import base64
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_json(data: str) -> bytes:
+    return base64.b64decode(data)

capo_codecatalyst/types/_prelude/timestamp.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: datetime.datetime) -> float:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.timestamp()
+
+
+def deserialize_json(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_codecatalyst/types/access_token_id.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#AccessTokenId``."""
+
+from typing import TypeAlias
+
+AccessTokenId: TypeAlias = str

capo_codecatalyst/types/access_token_name.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#AccessTokenName``."""
+
+from typing import TypeAlias
+
+AccessTokenName: TypeAlias = str

capo_codecatalyst/types/access_token_secret.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#AccessTokenSecret``."""
+
+from typing import TypeAlias
+
+AccessTokenSecret: TypeAlias = str