capo-lambda-microvms 0.1.0__py3-none-any.whl

capo_lambda_microvms/types/logging_disabled.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#LoggingDisabled``."""
+
+from typing_extensions import TypedDict
+
+
+class LoggingDisabled(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LoggingDisabled) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> LoggingDisabled:
+    out: LoggingDisabled = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda_microvms/types/managed_microvm_image_summary.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ManagedMicrovmImageSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_lambda_microvms.types.non_blank_string
+
+
+class ManagedMicrovmImageSummary(TypedDict, closed=True):
+    image_arn: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The ARN of the managed MicroVM image.</p>"""
+    created_at: "datetime.datetime"
+    """<p>The timestamp when the managed MicroVM image was created.</p>"""
+    updated_at: NotRequired["datetime.datetime"]
+    """<p>The timestamp when the managed MicroVM image was last updated.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ManagedMicrovmImageSummary) -> dict:
+    out: dict = {}
+    out["imageArn"] = value["image_arn"]
+    import capo_lambda_microvms.types._prelude.timestamp
+
+    out["createdAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+        value["created_at"]
+    )
+    if "updated_at" in value:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["updatedAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+            value["updated_at"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ManagedMicrovmImageSummary:
+    out: ManagedMicrovmImageSummary = {}  # type: ignore[typeddict-item]
+    if data.get("imageArn") is not None:
+        out["image_arn"] = data["imageArn"]
+    else:
+        raise DeserializationError("ManagedMicrovmImageSummary.image_arn required")
+    if data.get("createdAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["created_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["createdAt"]
+            )
+        )
+    else:
+        raise DeserializationError("ManagedMicrovmImageSummary.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["updated_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["updatedAt"]
+            )
+        )
+    return out

capo_lambda_microvms/types/managed_microvm_image_summary_list.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ManagedMicrovmImageSummaryList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.managed_microvm_image_summary
+
+ManagedMicrovmImageSummaryList: TypeAlias = list[
+    "capo_lambda_microvms.types.managed_microvm_image_summary.ManagedMicrovmImageSummary"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ManagedMicrovmImageSummaryList) -> list:
+    import capo_lambda_microvms.types.managed_microvm_image_summary
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_lambda_microvms.types.managed_microvm_image_summary.serialize_json(
+                item
+            )
+        )
+    return out
+
+
+def deserialize_json(data: list) -> ManagedMicrovmImageSummaryList:
+    import capo_lambda_microvms.types.managed_microvm_image_summary
+
+    out: ManagedMicrovmImageSummaryList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_lambda_microvms.types.managed_microvm_image_summary.deserialize_json(
+                item
+            )
+        )
+    return out

capo_lambda_microvms/types/managed_microvm_image_version.py

@@ -0,0 +1,94 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ManagedMicrovmImageVersion``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_lambda_microvms.types.managed_microvm_image_version_status
+    import capo_lambda_microvms.types.non_blank_string
+
+
+class ManagedMicrovmImageVersion(TypedDict, closed=True):
+    image_arn: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The ARN of the managed MicroVM image.</p>"""
+    image_version: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The version of the managed MicroVM image.</p>"""
+    status: NotRequired[
+        "capo_lambda_microvms.types.managed_microvm_image_version_status.ManagedMicrovmImageVersionStatus"
+    ]
+    """<p>The lifecycle status of the managed MicroVM image version. Valid values: AVAILABLE (the version is available for use) or DEPRECATED (the version is deprecated; do not use it for new MicroVM images).</p>"""
+    created_at: "datetime.datetime"
+    """<p>The timestamp when the version was created.</p>"""
+    updated_at: NotRequired["datetime.datetime"]
+    """<p>The timestamp when the version was last updated.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ManagedMicrovmImageVersion) -> dict:
+    out: dict = {}
+    out["imageArn"] = value["image_arn"]
+    out["imageVersion"] = value["image_version"]
+    if "status" in value:
+        import capo_lambda_microvms.types.managed_microvm_image_version_status
+
+        out["status"] = (
+            capo_lambda_microvms.types.managed_microvm_image_version_status.serialize_json(
+                value["status"]
+            )
+        )
+    import capo_lambda_microvms.types._prelude.timestamp
+
+    out["createdAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+        value["created_at"]
+    )
+    if "updated_at" in value:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["updatedAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+            value["updated_at"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ManagedMicrovmImageVersion:
+    out: ManagedMicrovmImageVersion = {}  # type: ignore[typeddict-item]
+    if data.get("imageArn") is not None:
+        out["image_arn"] = data["imageArn"]
+    else:
+        raise DeserializationError("ManagedMicrovmImageVersion.image_arn required")
+    if data.get("imageVersion") is not None:
+        out["image_version"] = data["imageVersion"]
+    else:
+        raise DeserializationError("ManagedMicrovmImageVersion.image_version required")
+    if data.get("status") is not None:
+        import capo_lambda_microvms.types.managed_microvm_image_version_status
+
+        out["status"] = (
+            capo_lambda_microvms.types.managed_microvm_image_version_status.deserialize_json(
+                data["status"]
+            )
+        )
+    if data.get("createdAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["created_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["createdAt"]
+            )
+        )
+    else:
+        raise DeserializationError("ManagedMicrovmImageVersion.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["updated_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["updatedAt"]
+            )
+        )
+    return out

capo_lambda_microvms/types/managed_microvm_image_version_list.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ManagedMicrovmImageVersionList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.managed_microvm_image_version
+
+ManagedMicrovmImageVersionList: TypeAlias = list[
+    "capo_lambda_microvms.types.managed_microvm_image_version.ManagedMicrovmImageVersion"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ManagedMicrovmImageVersionList) -> list:
+    import capo_lambda_microvms.types.managed_microvm_image_version
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_lambda_microvms.types.managed_microvm_image_version.serialize_json(
+                item
+            )
+        )
+    return out
+
+
+def deserialize_json(data: list) -> ManagedMicrovmImageVersionList:
+    import capo_lambda_microvms.types.managed_microvm_image_version
+
+    out: ManagedMicrovmImageVersionList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_lambda_microvms.types.managed_microvm_image_version.deserialize_json(
+                item
+            )
+        )
+    return out

capo_lambda_microvms/types/managed_microvm_image_version_status.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ManagedMicrovmImageVersionStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>The lifecycle status of a managed MicroVM image version.</p>"""
+ManagedMicrovmImageVersionStatus: TypeAlias = Literal[
+    "AVAILABLE",
+    "DEPRECATED",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ManagedMicrovmImageVersionStatus) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ManagedMicrovmImageVersionStatus:
+    return cast(ManagedMicrovmImageVersionStatus, data)

capo_lambda_microvms/types/microvm_hooks.py

@@ -0,0 +1,108 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmHooks``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.hook_state
+
+
+class MicrovmHooks(TypedDict, closed=True):
+    run: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked when the MicroVM starts running.</p>"""
+    run_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the run hook to complete.</p>"""
+    resume: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked when the MicroVM resumes from a suspended state.</p>"""
+    resume_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the resume hook to complete.</p>"""
+    suspend: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked when the MicroVM is suspended.</p>"""
+    suspend_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the suspend hook to complete.</p>"""
+    terminate: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked when the MicroVM is terminated.</p>"""
+    terminate_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the terminate hook to complete.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MicrovmHooks) -> dict:
+    out: dict = {}
+    import capo_lambda_microvms.types.hook_state
+
+    out["run"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("run", "DISABLED")
+    )
+    out["runTimeoutInSeconds"] = value.get("run_timeout_in_seconds", 1)
+    import capo_lambda_microvms.types.hook_state
+
+    out["resume"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("resume", "DISABLED")
+    )
+    out["resumeTimeoutInSeconds"] = value.get("resume_timeout_in_seconds", 1)
+    import capo_lambda_microvms.types.hook_state
+
+    out["suspend"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("suspend", "DISABLED")
+    )
+    out["suspendTimeoutInSeconds"] = value.get("suspend_timeout_in_seconds", 1)
+    import capo_lambda_microvms.types.hook_state
+
+    out["terminate"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("terminate", "DISABLED")
+    )
+    out["terminateTimeoutInSeconds"] = value.get("terminate_timeout_in_seconds", 1)
+    return out
+
+
+def deserialize_json(data: dict) -> MicrovmHooks:
+    out: MicrovmHooks = {}  # type: ignore[typeddict-item]
+    if data.get("run") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["run"] = capo_lambda_microvms.types.hook_state.deserialize_json(data["run"])
+    else:
+        out["run"] = "DISABLED"
+    if data.get("runTimeoutInSeconds") is not None:
+        out["run_timeout_in_seconds"] = data["runTimeoutInSeconds"]
+    else:
+        out["run_timeout_in_seconds"] = 1
+    if data.get("resume") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["resume"] = capo_lambda_microvms.types.hook_state.deserialize_json(
+            data["resume"]
+        )
+    else:
+        out["resume"] = "DISABLED"
+    if data.get("resumeTimeoutInSeconds") is not None:
+        out["resume_timeout_in_seconds"] = data["resumeTimeoutInSeconds"]
+    else:
+        out["resume_timeout_in_seconds"] = 1
+    if data.get("suspend") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["suspend"] = capo_lambda_microvms.types.hook_state.deserialize_json(
+            data["suspend"]
+        )
+    else:
+        out["suspend"] = "DISABLED"
+    if data.get("suspendTimeoutInSeconds") is not None:
+        out["suspend_timeout_in_seconds"] = data["suspendTimeoutInSeconds"]
+    else:
+        out["suspend_timeout_in_seconds"] = 1
+    if data.get("terminate") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["terminate"] = capo_lambda_microvms.types.hook_state.deserialize_json(
+            data["terminate"]
+        )
+    else:
+        out["terminate"] = "DISABLED"
+    if data.get("terminateTimeoutInSeconds") is not None:
+        out["terminate_timeout_in_seconds"] = data["terminateTimeoutInSeconds"]
+    else:
+        out["terminate_timeout_in_seconds"] = 1
+    return out

capo_lambda_microvms/types/microvm_identifier.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmIdentifier``."""
+
+from typing import TypeAlias
+
+"""The ARN or ID of the MicroVm"""
+MicrovmIdentifier: TypeAlias = str

capo_lambda_microvms/types/microvm_image_arn.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageArn``."""
+
+from typing import TypeAlias
+
+"""MicroVm Image Arn"""
+MicrovmImageArn: TypeAlias = str

capo_lambda_microvms/types/microvm_image_build_summaries.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageBuildSummaries``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.microvm_image_build_summary
+
+MicrovmImageBuildSummaries: TypeAlias = list[
+    "capo_lambda_microvms.types.microvm_image_build_summary.MicrovmImageBuildSummary"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MicrovmImageBuildSummaries) -> list:
+    import capo_lambda_microvms.types.microvm_image_build_summary
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_lambda_microvms.types.microvm_image_build_summary.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> MicrovmImageBuildSummaries:
+    import capo_lambda_microvms.types.microvm_image_build_summary
+
+    out: MicrovmImageBuildSummaries = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_lambda_microvms.types.microvm_image_build_summary.deserialize_json(
+                item
+            )
+        )
+    return out

capo_lambda_microvms/types/microvm_image_build_summary.py

@@ -0,0 +1,125 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageBuildSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_lambda_microvms.types.architecture
+    import capo_lambda_microvms.types.build_state
+    import capo_lambda_microvms.types.chipset
+    import capo_lambda_microvms.types.non_blank_string
+
+
+class MicrovmImageBuildSummary(TypedDict, closed=True):
+    image_arn: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The ARN of the MicroVM image.</p>"""
+    image_version: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The version of the MicroVM image.</p>"""
+    build_id: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The build request ID.</p>"""
+    build_state: "capo_lambda_microvms.types.build_state.BuildState"
+    """<p>The current state of the build.</p>"""
+    architecture: "capo_lambda_microvms.types.architecture.Architecture"
+    """<p>The target CPU architecture for the build. Supported value: ARM_64.</p>"""
+    chipset: "capo_lambda_microvms.types.chipset.Chipset"
+    """<p>The target chipset for the build.</p>"""
+    chipset_generation: "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    """<p>The target chipset generation for the build.</p>"""
+    state_reason: NotRequired["str"]
+    """<p>The reason for the build state, if applicable.</p>"""
+    created_at: "datetime.datetime"
+    """<p>The timestamp when the build was created.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MicrovmImageBuildSummary) -> dict:
+    out: dict = {}
+    out["imageArn"] = value["image_arn"]
+    out["imageVersion"] = value["image_version"]
+    out["buildId"] = value["build_id"]
+    import capo_lambda_microvms.types.build_state
+
+    out["buildState"] = capo_lambda_microvms.types.build_state.serialize_json(
+        value["build_state"]
+    )
+    import capo_lambda_microvms.types.architecture
+
+    out["architecture"] = capo_lambda_microvms.types.architecture.serialize_json(
+        value["architecture"]
+    )
+    import capo_lambda_microvms.types.chipset
+
+    out["chipset"] = capo_lambda_microvms.types.chipset.serialize_json(value["chipset"])
+    out["chipsetGeneration"] = value["chipset_generation"]
+    if "state_reason" in value:
+        out["stateReason"] = value["state_reason"]
+    import capo_lambda_microvms.types._prelude.timestamp
+
+    out["createdAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+        value["created_at"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> MicrovmImageBuildSummary:
+    out: MicrovmImageBuildSummary = {}  # type: ignore[typeddict-item]
+    if data.get("imageArn") is not None:
+        out["image_arn"] = data["imageArn"]
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.image_arn required")
+    if data.get("imageVersion") is not None:
+        out["image_version"] = data["imageVersion"]
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.image_version required")
+    if data.get("buildId") is not None:
+        out["build_id"] = data["buildId"]
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.build_id required")
+    if data.get("buildState") is not None:
+        import capo_lambda_microvms.types.build_state
+
+        out["build_state"] = capo_lambda_microvms.types.build_state.deserialize_json(
+            data["buildState"]
+        )
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.build_state required")
+    if data.get("architecture") is not None:
+        import capo_lambda_microvms.types.architecture
+
+        out["architecture"] = capo_lambda_microvms.types.architecture.deserialize_json(
+            data["architecture"]
+        )
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.architecture required")
+    if data.get("chipset") is not None:
+        import capo_lambda_microvms.types.chipset
+
+        out["chipset"] = capo_lambda_microvms.types.chipset.deserialize_json(
+            data["chipset"]
+        )
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.chipset required")
+    if data.get("chipsetGeneration") is not None:
+        out["chipset_generation"] = data["chipsetGeneration"]
+    else:
+        raise DeserializationError(
+            "MicrovmImageBuildSummary.chipset_generation required"
+        )
+    if data.get("stateReason") is not None:
+        out["state_reason"] = data["stateReason"]
+    if data.get("createdAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["created_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["createdAt"]
+            )
+        )
+    else:
+        raise DeserializationError("MicrovmImageBuildSummary.created_at required")
+    return out

capo_lambda_microvms/types/microvm_image_hooks.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageHooks``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.hook_state
+
+
+class MicrovmImageHooks(TypedDict, closed=True):
+    ready: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked when the MicroVM image build is ready.</p>"""
+    ready_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the ready hook to complete.</p>"""
+    validate: "capo_lambda_microvms.types.hook_state.HookState"
+    """<p>The path of the hook invoked to validate the MicroVM image build.</p>"""
+    validate_timeout_in_seconds: "int"
+    """<p>The maximum time in seconds for the validate hook to complete.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MicrovmImageHooks) -> dict:
+    out: dict = {}
+    import capo_lambda_microvms.types.hook_state
+
+    out["ready"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("ready", "DISABLED")
+    )
+    out["readyTimeoutInSeconds"] = value.get("ready_timeout_in_seconds", 30)
+    import capo_lambda_microvms.types.hook_state
+
+    out["validate"] = capo_lambda_microvms.types.hook_state.serialize_json(
+        value.get("validate", "DISABLED")
+    )
+    out["validateTimeoutInSeconds"] = value.get("validate_timeout_in_seconds", 30)
+    return out
+
+
+def deserialize_json(data: dict) -> MicrovmImageHooks:
+    out: MicrovmImageHooks = {}  # type: ignore[typeddict-item]
+    if data.get("ready") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["ready"] = capo_lambda_microvms.types.hook_state.deserialize_json(
+            data["ready"]
+        )
+    else:
+        out["ready"] = "DISABLED"
+    if data.get("readyTimeoutInSeconds") is not None:
+        out["ready_timeout_in_seconds"] = data["readyTimeoutInSeconds"]
+    else:
+        out["ready_timeout_in_seconds"] = 30
+    if data.get("validate") is not None:
+        import capo_lambda_microvms.types.hook_state
+
+        out["validate"] = capo_lambda_microvms.types.hook_state.deserialize_json(
+            data["validate"]
+        )
+    else:
+        out["validate"] = "DISABLED"
+    if data.get("validateTimeoutInSeconds") is not None:
+        out["validate_timeout_in_seconds"] = data["validateTimeoutInSeconds"]
+    else:
+        out["validate_timeout_in_seconds"] = 30
+    return out

capo_lambda_microvms/types/microvm_image_identifier.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageIdentifier``."""
+
+from typing import TypeAlias
+
+"""The ARN or ID of the MicroVmImage"""
+MicrovmImageIdentifier: TypeAlias = str

capo_lambda_microvms/types/microvm_image_state.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#MicrovmImageState``."""
+
+from typing import Literal, TypeAlias, cast
+
+MicrovmImageState: TypeAlias = Literal[
+    "CREATING",
+    "CREATED",
+    "CREATE_FAILED",
+    "UPDATING",
+    "UPDATED",
+    "UPDATE_FAILED",
+    "DELETING",
+    "DELETE_FAILED",
+    "DELETED",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MicrovmImageState) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> MicrovmImageState:
+    return cast(MicrovmImageState, data)