capo-codedeploy 0.1.0__py3-none-any.whl

capo_codedeploy/errors/git_hub_account_token_does_not_exist_exception.py

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

capo_codedeploy/errors/git_hub_account_token_name_required_exception.py

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

capo_codedeploy/errors/iam_arn_required_exception.py

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

capo_codedeploy/errors/iam_session_arn_already_registered_exception.py

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

capo_codedeploy/errors/iam_user_arn_already_registered_exception.py

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

capo_codedeploy/errors/iam_user_arn_required_exception.py

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

capo_codedeploy/errors/instance_does_not_exist_exception.py

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

capo_codedeploy/errors/instance_id_required_exception.py

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

capo_codedeploy/errors/instance_limit_exceeded_exception.py

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

capo_codedeploy/errors/instance_name_already_registered_exception.py

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

capo_codedeploy/errors/instance_name_required_exception.py

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

capo_codedeploy/errors/instance_not_registered_exception.py

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