capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/invalid_target_group_pair_exception.py

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

capo_codedeploy/errors/invalid_target_instances_exception.py

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

capo_codedeploy/errors/invalid_time_range_exception.py

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

capo_codedeploy/errors/invalid_traffic_routing_configuration_exception.py

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

capo_codedeploy/errors/invalid_trigger_config_exception.py

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

capo_codedeploy/errors/invalid_update_outdated_instances_only_value_exception.py

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

capo_codedeploy/errors/invalid_zonal_deployment_configuration_exception.py

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

capo_codedeploy/errors/lifecycle_event_already_completed_exception.py

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

capo_codedeploy/errors/lifecycle_hook_limit_exceeded_exception.py

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

capo_codedeploy/errors/multiple_iam_arns_provided_exception.py

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

capo_codedeploy/errors/operation_not_supported_exception.py

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

capo_codedeploy/errors/resource_arn_required_exception.py

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