capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/invalid_iam_session_arn_exception.py

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

capo_codedeploy/errors/invalid_iam_user_arn_exception.py

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

capo_codedeploy/errors/invalid_ignore_application_stop_failures_value_exception.py

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

capo_codedeploy/errors/invalid_input_exception.py

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

capo_codedeploy/errors/invalid_instance_name_exception.py

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

capo_codedeploy/errors/invalid_instance_status_exception.py

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

capo_codedeploy/errors/invalid_instance_type_exception.py

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

capo_codedeploy/errors/invalid_key_prefix_filter_exception.py

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

capo_codedeploy/errors/invalid_lifecycle_event_hook_execution_id_exception.py

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

capo_codedeploy/errors/invalid_lifecycle_event_hook_execution_status_exception.py

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

capo_codedeploy/errors/invalid_load_balancer_info_exception.py

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

capo_codedeploy/errors/invalid_minimum_healthy_host_value_exception.py

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