capo-workdocs 0.1.0__py3-none-any.whl

capo_workdocs/errors/illegal_user_state_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#IllegalUserStateException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class IllegalUserStateException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: IllegalUserStateException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> IllegalUserStateException_:
+    out: IllegalUserStateException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class IllegalUserStateException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#IllegalUserStateException``."""
+
+    code: str | None = "IllegalUserStateException"
+
+    def __init__(self, data: IllegalUserStateException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="IllegalUserStateException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "IllegalUserStateException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/invalid_argument_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#InvalidArgumentException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class InvalidArgumentException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvalidArgumentException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvalidArgumentException_:
+    out: InvalidArgumentException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidArgumentException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#InvalidArgumentException``."""
+
+    code: str | None = "InvalidArgumentException"
+
+    def __init__(self, data: InvalidArgumentException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidArgumentException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidArgumentException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/invalid_comment_operation_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#InvalidCommentOperationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class InvalidCommentOperationException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvalidCommentOperationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvalidCommentOperationException_:
+    out: InvalidCommentOperationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidCommentOperationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#InvalidCommentOperationException``."""
+
+    code: str | None = "InvalidCommentOperationException"
+
+    def __init__(
+        self, data: InvalidCommentOperationException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidCommentOperationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidCommentOperationException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/invalid_operation_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#InvalidOperationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class InvalidOperationException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvalidOperationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvalidOperationException_:
+    out: InvalidOperationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidOperationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#InvalidOperationException``."""
+
+    code: str | None = "InvalidOperationException"
+
+    def __init__(self, data: InvalidOperationException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidOperationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidOperationException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/invalid_password_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#InvalidPasswordException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class InvalidPasswordException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvalidPasswordException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvalidPasswordException_:
+    out: InvalidPasswordException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class InvalidPasswordException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#InvalidPasswordException``."""
+
+    code: str | None = "InvalidPasswordException"
+
+    def __init__(self, data: InvalidPasswordException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidPasswordException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidPasswordException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/limit_exceeded_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#LimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class LimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> LimitExceededException_:
+    out: LimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class LimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#LimitExceededException``."""
+
+    code: str | None = "LimitExceededException"
+
+    def __init__(self, data: LimitExceededException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="LimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "LimitExceededException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/prohibited_state_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#ProhibitedStateException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class ProhibitedStateException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProhibitedStateException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProhibitedStateException_:
+    out: ProhibitedStateException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ProhibitedStateException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#ProhibitedStateException``."""
+
+    code: str | None = "ProhibitedStateException"
+
+    def __init__(self, data: ProhibitedStateException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ProhibitedStateException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ProhibitedStateException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/requested_entity_too_large_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#RequestedEntityTooLargeException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class RequestedEntityTooLargeException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RequestedEntityTooLargeException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> RequestedEntityTooLargeException_:
+    out: RequestedEntityTooLargeException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class RequestedEntityTooLargeException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#RequestedEntityTooLargeException``."""
+
+    code: str | None = "RequestedEntityTooLargeException"
+
+    def __init__(
+        self, data: RequestedEntityTooLargeException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="RequestedEntityTooLargeException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "RequestedEntityTooLargeException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/resource_already_checked_out_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#ResourceAlreadyCheckedOutException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class ResourceAlreadyCheckedOutException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResourceAlreadyCheckedOutException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ResourceAlreadyCheckedOutException_:
+    out: ResourceAlreadyCheckedOutException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ResourceAlreadyCheckedOutException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#ResourceAlreadyCheckedOutException``."""
+
+    code: str | None = "ResourceAlreadyCheckedOutException"
+
+    def __init__(
+        self, data: ResourceAlreadyCheckedOutException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ResourceAlreadyCheckedOutException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ResourceAlreadyCheckedOutException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/service_unavailable_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#ServiceUnavailableException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class ServiceUnavailableException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ServiceUnavailableException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ServiceUnavailableException_:
+    out: ServiceUnavailableException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class ServiceUnavailableException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#ServiceUnavailableException``."""
+
+    code: str | None = "ServiceUnavailableException"
+
+    def __init__(self, data: ServiceUnavailableException_, message: str | None = None):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="ServiceUnavailableException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "ServiceUnavailableException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/storage_limit_exceeded_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#StorageLimitExceededException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class StorageLimitExceededException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StorageLimitExceededException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> StorageLimitExceededException_:
+    out: StorageLimitExceededException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class StorageLimitExceededException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#StorageLimitExceededException``."""
+
+    code: str | None = "StorageLimitExceededException"
+
+    def __init__(
+        self, data: StorageLimitExceededException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="StorageLimitExceededException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "StorageLimitExceededException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/storage_limit_will_exceed_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#StorageLimitWillExceedException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class StorageLimitWillExceedException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StorageLimitWillExceedException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> StorageLimitWillExceedException_:
+    out: StorageLimitWillExceedException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class StorageLimitWillExceedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#StorageLimitWillExceedException``."""
+
+    code: str | None = "StorageLimitWillExceedException"
+
+    def __init__(
+        self, data: StorageLimitWillExceedException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="StorageLimitWillExceedException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "StorageLimitWillExceedException":
+        return cls(deserialize_json(data), message)

capo_workdocs/errors/too_many_labels_exception.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.workdocs#TooManyLabelsException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workdocs.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_workdocs.types.error_message_type
+
+
+class TooManyLabelsException_(TypedDict, closed=True):
+    message: NotRequired["capo_workdocs.types.error_message_type.ErrorMessageType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TooManyLabelsException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> TooManyLabelsException_:
+    out: TooManyLabelsException_ = {}  # type: ignore[typeddict-item]
+    if data.get("Message") is not None:
+        out["message"] = data["Message"]
+    return out
+
+
+class TooManyLabelsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.workdocs#TooManyLabelsException``."""
+
+    code: str | None = "TooManyLabelsException"
+
+    def __init__(self, data: TooManyLabelsException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TooManyLabelsException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(
+        cls, data: dict, message: str | None = None
+    ) -> "TooManyLabelsException":
+        return cls(deserialize_json(data), message)