capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/invalid_deployment_instance_type_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentInstanceTypeException``."""
+
+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 InvalidDeploymentInstanceTypeException_(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: InvalidDeploymentInstanceTypeException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidDeploymentInstanceTypeException_:
+    out: InvalidDeploymentInstanceTypeException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidDeploymentInstanceTypeException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentInstanceTypeException``."""
+
+    code: str | None = "InvalidDeploymentInstanceTypeException"
+
+    def __init__(
+        self, data: InvalidDeploymentInstanceTypeException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidDeploymentInstanceTypeException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidDeploymentInstanceTypeException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_deployment_status_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentStatusException``."""
+
+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 InvalidDeploymentStatusException_(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: InvalidDeploymentStatusException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidDeploymentStatusException_:
+    out: InvalidDeploymentStatusException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidDeploymentStatusException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentStatusException``."""
+
+    code: str | None = "InvalidDeploymentStatusException"
+
+    def __init__(
+        self, data: InvalidDeploymentStatusException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidDeploymentStatusException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidDeploymentStatusException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_deployment_style_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentStyleException``."""
+
+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 InvalidDeploymentStyleException_(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: InvalidDeploymentStyleException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidDeploymentStyleException_:
+    out: InvalidDeploymentStyleException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidDeploymentStyleException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentStyleException``."""
+
+    code: str | None = "InvalidDeploymentStyleException"
+
+    def __init__(
+        self, data: InvalidDeploymentStyleException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidDeploymentStyleException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidDeploymentStyleException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_deployment_target_id_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentTargetIdException``."""
+
+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 InvalidDeploymentTargetIdException_(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: InvalidDeploymentTargetIdException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidDeploymentTargetIdException_:
+    out: InvalidDeploymentTargetIdException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidDeploymentTargetIdException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentTargetIdException``."""
+
+    code: str | None = "InvalidDeploymentTargetIdException"
+
+    def __init__(
+        self, data: InvalidDeploymentTargetIdException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidDeploymentTargetIdException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidDeploymentTargetIdException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_deployment_wait_type_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentWaitTypeException``."""
+
+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 InvalidDeploymentWaitTypeException_(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: InvalidDeploymentWaitTypeException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidDeploymentWaitTypeException_:
+    out: InvalidDeploymentWaitTypeException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidDeploymentWaitTypeException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidDeploymentWaitTypeException``."""
+
+    code: str | None = "InvalidDeploymentWaitTypeException"
+
+    def __init__(
+        self, data: InvalidDeploymentWaitTypeException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidDeploymentWaitTypeException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidDeploymentWaitTypeException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_ec2_tag_combination_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidEC2TagCombinationException``."""
+
+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 InvalidEC2TagCombinationException_(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: InvalidEC2TagCombinationException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidEC2TagCombinationException_:
+    out: InvalidEC2TagCombinationException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidEC2TagCombinationException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidEC2TagCombinationException``."""
+
+    code: str | None = "InvalidEC2TagCombinationException"
+
+    def __init__(
+        self, data: InvalidEC2TagCombinationException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidEC2TagCombinationException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidEC2TagCombinationException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_ec2_tag_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidEC2TagException``."""
+
+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 InvalidEC2TagException_(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: InvalidEC2TagException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidEC2TagException_:
+    out: InvalidEC2TagException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidEC2TagException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidEC2TagException``."""
+
+    code: str | None = "InvalidEC2TagException"
+
+    def __init__(self, data: InvalidEC2TagException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidEC2TagException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidEC2TagException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_ecs_service_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidECSServiceException``."""
+
+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 InvalidECSServiceException_(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: InvalidECSServiceException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidECSServiceException_:
+    out: InvalidECSServiceException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidECSServiceException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidECSServiceException``."""
+
+    code: str | None = "InvalidECSServiceException"
+
+    def __init__(self, data: InvalidECSServiceException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidECSServiceException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidECSServiceException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_external_id_exception.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidExternalIdException``."""
+
+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 InvalidExternalIdException_(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: InvalidExternalIdException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidExternalIdException_:
+    out: InvalidExternalIdException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidExternalIdException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidExternalIdException``."""
+
+    code: str | None = "InvalidExternalIdException"
+
+    def __init__(self, data: InvalidExternalIdException_, message: str | None = None):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidExternalIdException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidExternalIdException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_file_exists_behavior_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidFileExistsBehaviorException``."""
+
+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 InvalidFileExistsBehaviorException_(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: InvalidFileExistsBehaviorException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidFileExistsBehaviorException_:
+    out: InvalidFileExistsBehaviorException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidFileExistsBehaviorException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidFileExistsBehaviorException``."""
+
+    code: str | None = "InvalidFileExistsBehaviorException"
+
+    def __init__(
+        self, data: InvalidFileExistsBehaviorException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidFileExistsBehaviorException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidFileExistsBehaviorException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_git_hub_account_token_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidGitHubAccountTokenException``."""
+
+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 InvalidGitHubAccountTokenException_(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: InvalidGitHubAccountTokenException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidGitHubAccountTokenException_:
+    out: InvalidGitHubAccountTokenException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidGitHubAccountTokenException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidGitHubAccountTokenException``."""
+
+    code: str | None = "InvalidGitHubAccountTokenException"
+
+    def __init__(
+        self, data: InvalidGitHubAccountTokenException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidGitHubAccountTokenException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidGitHubAccountTokenException":
+        return cls(deserialize_aws_json_1_1(data), message)

capo_codedeploy/errors/invalid_git_hub_account_token_name_exception.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codedeploy#InvalidGitHubAccountTokenNameException``."""
+
+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 InvalidGitHubAccountTokenNameException_(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: InvalidGitHubAccountTokenNameException_) -> dict:
+    out: dict = {}
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> InvalidGitHubAccountTokenNameException_:
+    out: InvalidGitHubAccountTokenNameException_ = {}  # type: ignore[typeddict-item]
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    return out
+
+
+class InvalidGitHubAccountTokenNameException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.codedeploy#InvalidGitHubAccountTokenNameException``."""
+
+    code: str | None = "InvalidGitHubAccountTokenNameException"
+
+    def __init__(
+        self, data: InvalidGitHubAccountTokenNameException_, message: str | None = None
+    ):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="InvalidGitHubAccountTokenNameException",
+            message=message,
+        )
+        self.data = data
+
+    @classmethod
+    def from_aws_json_1_1(
+        cls, data: dict, message: str | None = None
+    ) -> "InvalidGitHubAccountTokenNameException":
+        return cls(deserialize_aws_json_1_1(data), message)