capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/application_name_required_exception.py

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

capo_codedeploy/errors/arn_not_supported_exception.py

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

capo_codedeploy/errors/batch_limit_exceeded_exception.py

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

capo_codedeploy/errors/bucket_name_filter_required_exception.py

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

capo_codedeploy/errors/deployment_already_completed_exception.py

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

capo_codedeploy/errors/deployment_config_already_exists_exception.py

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

capo_codedeploy/errors/deployment_config_does_not_exist_exception.py

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

capo_codedeploy/errors/deployment_config_in_use_exception.py

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

capo_codedeploy/errors/deployment_config_limit_exceeded_exception.py

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

capo_codedeploy/errors/deployment_config_name_required_exception.py

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

capo_codedeploy/errors/deployment_does_not_exist_exception.py

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

capo_codedeploy/errors/deployment_group_already_exists_exception.py

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