capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/invalid_next_token_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidNextTokenException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidNextTokenException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidNextTokenException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidNextTokenException_:
+    out: InvalidNextTokenException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidNextTokenException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidNextTokenException``."""
+
+    code: str | None = "InvalidNextTokenException"
+
+    def __init__(self, data: InvalidNextTokenException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidNextTokenException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidNextTokenException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_on_premises_tag_combination_exception.py

@@ -0,0 +1,56 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidOnPremisesTagCombinationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidOnPremisesTagCombinationException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidOnPremisesTagCombinationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidOnPremisesTagCombinationException_:
+    out: InvalidOnPremisesTagCombinationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidOnPremisesTagCombinationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidOnPremisesTagCombinationException``."""
+
+    code: str | None = "InvalidOnPremisesTagCombinationException"
+
+    def __init__(
+        self,
+        data: InvalidOnPremisesTagCombinationException_,
+        message: str | None = None,
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidOnPremisesTagCombinationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidOnPremisesTagCombinationException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_operation_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidOperationException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidOperationException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidOperationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(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.codedeploy#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_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidOperationException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_registration_status_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidRegistrationStatusException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidRegistrationStatusException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidRegistrationStatusException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidRegistrationStatusException_:
+    out: InvalidRegistrationStatusException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidRegistrationStatusException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidRegistrationStatusException``."""
+
+    code: str | None = "InvalidRegistrationStatusException"
+
+    def __init__(
+        self, data: InvalidRegistrationStatusException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidRegistrationStatusException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidRegistrationStatusException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_revision_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidRevisionException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidRevisionException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidRevisionException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidRevisionException_:
+    out: InvalidRevisionException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidRevisionException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidRevisionException``."""
+
+    code: str | None = "InvalidRevisionException"
+
+    def __init__(self, data: InvalidRevisionException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidRevisionException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidRevisionException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_role_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidRoleException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidRoleException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidRoleException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidRoleException_:
+    out: InvalidRoleException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidRoleException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidRoleException``."""
+
+    code: str | None = "InvalidRoleException"
+
+    def __init__(self, data: InvalidRoleException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidRoleException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidRoleException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_sort_by_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidSortByException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidSortByException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidSortByException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidSortByException_:
+    out: InvalidSortByException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidSortByException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidSortByException``."""
+
+    code: str | None = "InvalidSortByException"
+
+    def __init__(self, data: InvalidSortByException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidSortByException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidSortByException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_sort_order_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidSortOrderException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidSortOrderException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidSortOrderException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidSortOrderException_:
+    out: InvalidSortOrderException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidSortOrderException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidSortOrderException``."""
+
+    code: str | None = "InvalidSortOrderException"
+
+    def __init__(self, data: InvalidSortOrderException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidSortOrderException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidSortOrderException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_tag_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidTagException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidTagException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidTagException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidTagException_:
+    out: InvalidTagException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidTagException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidTagException``."""
+
+    code: str | None = "InvalidTagException"
+
+    def __init__(self, data: InvalidTagException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidTagException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidTagException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_tag_filter_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidTagFilterException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidTagFilterException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidTagFilterException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidTagFilterException_:
+    out: InvalidTagFilterException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidTagFilterException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidTagFilterException``."""
+
+    code: str | None = "InvalidTagFilterException"
+
+    def __init__(self, data: InvalidTagFilterException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidTagFilterException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidTagFilterException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_tags_to_add_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidTagsToAddException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidTagsToAddException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidTagsToAddException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidTagsToAddException_:
+    out: InvalidTagsToAddException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidTagsToAddException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidTagsToAddException``."""
+
+    code: str | None = "InvalidTagsToAddException"
+
+    def __init__(self, data: InvalidTagsToAddException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidTagsToAddException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidTagsToAddException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_target_filter_name_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidTargetFilterNameException``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codedeploy.errors import ServiceError
+
+if TYPE_CHECKING:
+    import capo_codedeploy.types.message
+
+
+class InvalidTargetFilterNameException_(TypedDict, closed=True):
+    message: NotRequired["capo_codedeploy.types.message.Message"]
+    """<p>The message that corresponds to the exception thrown by CodeDeploy.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: InvalidTargetFilterNameException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidTargetFilterNameException_:
+    out: InvalidTargetFilterNameException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidTargetFilterNameException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidTargetFilterNameException``."""
+
+    code: str | None = "InvalidTargetFilterNameException"
+
+    def __init__(
+        self, data: InvalidTargetFilterNameException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidTargetFilterNameException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidTargetFilterNameException":
+        return cls(deserialize_aws_json_1_1(data), message)