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

capo_lambda_microvms/types/port_number.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#PortNumber``."""
+
+from typing import TypeAlias
+
+"""Represents a single port."""
+PortNumber: TypeAlias = int

capo_lambda_microvms/types/port_range.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#PortRange``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.port_number
+
+
+class PortRange(TypedDict, closed=True):
+    start_port: "capo_lambda_microvms.types.port_number.PortNumber"
+    """<p>The starting port number of the range.</p>"""
+    end_port: "capo_lambda_microvms.types.port_number.PortNumber"
+    """<p>The ending port number of the range.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PortRange) -> dict:
+    out: dict = {}
+    out["startPort"] = value["start_port"]
+    out["endPort"] = value["end_port"]
+    return out
+
+
+def deserialize_json(data: dict) -> PortRange:
+    out: PortRange = {}  # type: ignore[typeddict-item]
+    if data.get("startPort") is not None:
+        out["start_port"] = data["startPort"]
+    else:
+        raise DeserializationError("PortRange.start_port required")
+    if data.get("endPort") is not None:
+        out["end_port"] = data["endPort"]
+    else:
+        raise DeserializationError("PortRange.end_port required")
+    return out

capo_lambda_microvms/types/port_specification.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#PortSpecification``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError, SerializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.port_number
+    import capo_lambda_microvms.types.port_range
+
+
+class _PortSpecification_port(TypedDict, closed=True):
+    port: "capo_lambda_microvms.types.port_number.PortNumber"
+
+
+class _PortSpecification_range(TypedDict, closed=True):
+    range: "capo_lambda_microvms.types.port_range.PortRange"
+
+
+class _PortSpecification_allPorts(TypedDict, closed=True):
+    allPorts: "None"
+
+
+PortSpecification: TypeAlias = (
+    _PortSpecification_port | _PortSpecification_range | _PortSpecification_allPorts
+)
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PortSpecification) -> dict:
+    if "port" in value:
+        return {"port": value["port"]}
+    elif "range" in value:
+        import capo_lambda_microvms.types.port_range
+
+        return {
+            "range": capo_lambda_microvms.types.port_range.serialize_json(
+                value["range"]
+            )
+        }
+    elif "allPorts" in value:
+        return {"allPorts": {}}
+    else:
+        raise SerializationError("PortSpecification: no variant present")
+
+
+def deserialize_json(data: dict) -> PortSpecification:
+    if data.get("port") is not None:
+        return {"port": data["port"]}
+    elif data.get("range") is not None:
+        import capo_lambda_microvms.types.port_range
+
+        return {
+            "range": capo_lambda_microvms.types.port_range.deserialize_json(
+                data["range"]
+            )
+        }
+    elif data.get("allPorts") is not None:
+        return {"allPorts": None}
+    else:
+        raise DeserializationError("PortSpecification: no recognized variant key")

capo_lambda_microvms/types/positive_integer.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#PositiveInteger``."""
+
+from typing import TypeAlias
+
+PositiveInteger: TypeAlias = int

capo_lambda_microvms/types/resources.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#Resources``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+
+class Resources(TypedDict, closed=True):
+    minimum_memory_in_mi_b: "int"
+    """<p>The minimum amount of memory in MiB to allocate to the MicroVM.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Resources) -> dict:
+    out: dict = {}
+    out["minimumMemoryInMiB"] = value["minimum_memory_in_mi_b"]
+    return out
+
+
+def deserialize_json(data: dict) -> Resources:
+    out: Resources = {}  # type: ignore[typeddict-item]
+    if data.get("minimumMemoryInMiB") is not None:
+        out["minimum_memory_in_mi_b"] = data["minimumMemoryInMiB"]
+    else:
+        raise DeserializationError("Resources.minimum_memory_in_mi_b required")
+    return out

capo_lambda_microvms/types/resources_list.py

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

capo_lambda_microvms/types/resume_microvm_request.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#ResumeMicrovmRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.microvm_identifier
+
+
+class ResumeMicrovmRequest(TypedDict, closed=True):
+    microvm_identifier: (
+        "capo_lambda_microvms.types.microvm_identifier.MicrovmIdentifier"
+    )
+    """<p>The ID of the MicroVM to resume.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ResumeMicrovmRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ResumeMicrovmRequest:
+    out: ResumeMicrovmRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda_microvms/types/resume_microvm_response.py

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

capo_lambda_microvms/types/role_arn.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#RoleArn``."""
+
+from typing import TypeAlias
+
+"""The ARN of an IAM role that the service assumes to perform actions on behalf of the caller."""
+RoleArn: TypeAlias = str

capo_lambda_microvms/types/run_hook_payload.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#RunHookPayload``."""
+
+from typing import TypeAlias
+
+RunHookPayload: TypeAlias = str

capo_lambda_microvms/types/run_microvm_request.py

@@ -0,0 +1,139 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#RunMicrovmRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_microvms.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.idle_policy
+    import capo_lambda_microvms.types.logging
+    import capo_lambda_microvms.types.microvm_image_identifier
+    import capo_lambda_microvms.types.network_connector_list
+    import capo_lambda_microvms.types.role_arn
+    import capo_lambda_microvms.types.run_hook_payload
+    import capo_lambda_microvms.types.version
+
+
+class RunMicrovmRequest(TypedDict, closed=True):
+    ingress_network_connectors: NotRequired[
+        "capo_lambda_microvms.types.network_connector_list.NetworkConnectorList"
+    ]
+    """<p>The list of ingress network connectors to configure for the MicroVM.</p>"""
+    egress_network_connectors: NotRequired[
+        "capo_lambda_microvms.types.network_connector_list.NetworkConnectorList"
+    ]
+    """<p>The list of egress network connectors to configure for the MicroVM.</p>"""
+    image_identifier: (
+        "capo_lambda_microvms.types.microvm_image_identifier.MicrovmImageIdentifier"
+    )
+    """<p>The identifier (ARN or ID) of the MicroVM image to run.</p>"""
+    image_version: NotRequired["capo_lambda_microvms.types.version.Version"]
+    """<p>The version of the MicroVM image to run.</p>"""
+    execution_role_arn: NotRequired["capo_lambda_microvms.types.role_arn.RoleArn"]
+    """<p>The ARN of the IAM role to be assumed by the MicroVM during execution.</p>"""
+    idle_policy: NotRequired["capo_lambda_microvms.types.idle_policy.IdlePolicy"]
+    """<p>Configuration to control auto-suspend and auto-resume behavior.</p>"""
+    logging: NotRequired["capo_lambda_microvms.types.logging.Logging"]
+    r"""<p>The logging configuration for this MicroVM instance. Specify {\"cloudWatch\": {\"logGroup\": \"...\"}} to stream application logs to a custom CloudWatch log group, or {\"disabled\": {}} to turn off logging.</p>"""
+    run_hook_payload: NotRequired[
+        "capo_lambda_microvms.types.run_hook_payload.RunHookPayload"
+    ]
+    """<p>Per-MicroVM initialization data delivered as the request body of the /run lifecycle hook. Use to pass tenant-specific configuration such as session IDs or secret references. Maximum: 16,384 bytes.</p>"""
+    maximum_duration_in_seconds: NotRequired["int"]
+    """<p>The maximum duration in seconds that the MicroVM can exist before being terminated by the platform. Valid range: 1–28,800 (8 hours).</p>"""
+    client_token: NotRequired["str"]
+    """<p>A unique, case-sensitive identifier you provide to ensure the idempotency of the request.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RunMicrovmRequest) -> dict:
+    out: dict = {}
+    if "ingress_network_connectors" in value:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["ingressNetworkConnectors"] = (
+            capo_lambda_microvms.types.network_connector_list.serialize_json(
+                value["ingress_network_connectors"]
+            )
+        )
+    if "egress_network_connectors" in value:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["egressNetworkConnectors"] = (
+            capo_lambda_microvms.types.network_connector_list.serialize_json(
+                value["egress_network_connectors"]
+            )
+        )
+    out["imageIdentifier"] = value["image_identifier"]
+    if "image_version" in value:
+        out["imageVersion"] = value["image_version"]
+    if "execution_role_arn" in value:
+        out["executionRoleArn"] = value["execution_role_arn"]
+    if "idle_policy" in value:
+        import capo_lambda_microvms.types.idle_policy
+
+        out["idlePolicy"] = capo_lambda_microvms.types.idle_policy.serialize_json(
+            value["idle_policy"]
+        )
+    if "logging" in value:
+        import capo_lambda_microvms.types.logging
+
+        out["logging"] = capo_lambda_microvms.types.logging.serialize_json(
+            value["logging"]
+        )
+    if "run_hook_payload" in value:
+        out["runHookPayload"] = value["run_hook_payload"]
+    if "maximum_duration_in_seconds" in value:
+        out["maximumDurationInSeconds"] = value["maximum_duration_in_seconds"]
+    if "client_token" in value:
+        out["clientToken"] = value["client_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> RunMicrovmRequest:
+    out: RunMicrovmRequest = {}  # type: ignore[typeddict-item]
+    if data.get("ingressNetworkConnectors") is not None:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["ingress_network_connectors"] = (
+            capo_lambda_microvms.types.network_connector_list.deserialize_json(
+                data["ingressNetworkConnectors"]
+            )
+        )
+    if data.get("egressNetworkConnectors") is not None:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["egress_network_connectors"] = (
+            capo_lambda_microvms.types.network_connector_list.deserialize_json(
+                data["egressNetworkConnectors"]
+            )
+        )
+    if data.get("imageIdentifier") is not None:
+        out["image_identifier"] = data["imageIdentifier"]
+    else:
+        raise DeserializationError("RunMicrovmRequest.image_identifier required")
+    if data.get("imageVersion") is not None:
+        out["image_version"] = data["imageVersion"]
+    if data.get("executionRoleArn") is not None:
+        out["execution_role_arn"] = data["executionRoleArn"]
+    if data.get("idlePolicy") is not None:
+        import capo_lambda_microvms.types.idle_policy
+
+        out["idle_policy"] = capo_lambda_microvms.types.idle_policy.deserialize_json(
+            data["idlePolicy"]
+        )
+    if data.get("logging") is not None:
+        import capo_lambda_microvms.types.logging
+
+        out["logging"] = capo_lambda_microvms.types.logging.deserialize_json(
+            data["logging"]
+        )
+    if data.get("runHookPayload") is not None:
+        out["run_hook_payload"] = data["runHookPayload"]
+    if data.get("maximumDurationInSeconds") is not None:
+        out["maximum_duration_in_seconds"] = data["maximumDurationInSeconds"]
+    if data.get("clientToken") is not None:
+        out["client_token"] = data["clientToken"]
+    return out

capo_lambda_microvms/types/run_microvm_response.py

@@ -0,0 +1,188 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#RunMicrovmResponse``."""
+
+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.idle_policy
+    import capo_lambda_microvms.types.microvm_identifier
+    import capo_lambda_microvms.types.microvm_image_arn
+    import capo_lambda_microvms.types.microvm_state
+    import capo_lambda_microvms.types.network_connector_list
+    import capo_lambda_microvms.types.non_blank_string
+    import capo_lambda_microvms.types.role_arn
+    import capo_lambda_microvms.types.version
+
+
+class RunMicrovmResponse(TypedDict, closed=True):
+    microvm_id: "capo_lambda_microvms.types.microvm_identifier.MicrovmIdentifier"
+    """<p>The unique identifier of the MicroVM.</p>"""
+    state: "capo_lambda_microvms.types.microvm_state.MicrovmState"
+    """<p>The current lifecycle state of the MicroVM.</p>"""
+    endpoint: "str"
+    """<p>The HTTPS endpoint URL for communicating with the MicroVM. Include a valid authentication token in the X-aws-proxy-auth header when sending requests.</p>"""
+    image_arn: "capo_lambda_microvms.types.microvm_image_arn.MicrovmImageArn"
+    """<p>The ARN of the MicroVM image used to run this MicroVM.</p>"""
+    image_version: "capo_lambda_microvms.types.version.Version"
+    """<p>The version of the MicroVM image used to run this MicroVM.</p>"""
+    execution_role_arn: NotRequired["capo_lambda_microvms.types.role_arn.RoleArn"]
+    """<p>The ARN of the IAM execution role assumed by the MicroVM.</p>"""
+    idle_policy: NotRequired["capo_lambda_microvms.types.idle_policy.IdlePolicy"]
+    """<p>The idle policy configuration of the MicroVM.</p>"""
+    maximum_duration_in_seconds: "int"
+    """<p>The maximum duration in seconds that the MicroVM can exist.</p>"""
+    started_at: "datetime.datetime"
+    """<p>The timestamp when the MicroVM first started.</p>"""
+    terminated_at: NotRequired["datetime.datetime"]
+    """<p>The timestamp when the MicroVM terminated.</p>"""
+    state_reason: NotRequired[
+        "capo_lambda_microvms.types.non_blank_string.NonBlankString"
+    ]
+    """<p>The reason for why the MicroVM is in the current state.</p>"""
+    ingress_network_connectors: NotRequired[
+        "capo_lambda_microvms.types.network_connector_list.NetworkConnectorList"
+    ]
+    """<p>The list of ingress network connectors configured for the MicroVM.</p>"""
+    egress_network_connectors: NotRequired[
+        "capo_lambda_microvms.types.network_connector_list.NetworkConnectorList"
+    ]
+    """<p>The list of egress network connectors configured for the MicroVM.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RunMicrovmResponse) -> dict:
+    out: dict = {}
+    out["microvmId"] = value["microvm_id"]
+    import capo_lambda_microvms.types.microvm_state
+
+    out["state"] = capo_lambda_microvms.types.microvm_state.serialize_json(
+        value["state"]
+    )
+    out["endpoint"] = value["endpoint"]
+    out["imageArn"] = value["image_arn"]
+    out["imageVersion"] = value["image_version"]
+    if "execution_role_arn" in value:
+        out["executionRoleArn"] = value["execution_role_arn"]
+    if "idle_policy" in value:
+        import capo_lambda_microvms.types.idle_policy
+
+        out["idlePolicy"] = capo_lambda_microvms.types.idle_policy.serialize_json(
+            value["idle_policy"]
+        )
+    out["maximumDurationInSeconds"] = value["maximum_duration_in_seconds"]
+    import capo_lambda_microvms.types._prelude.timestamp
+
+    out["startedAt"] = capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+        value["started_at"]
+    )
+    if "terminated_at" in value:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["terminatedAt"] = (
+            capo_lambda_microvms.types._prelude.timestamp.serialize_json(
+                value["terminated_at"]
+            )
+        )
+    if "state_reason" in value:
+        out["stateReason"] = value["state_reason"]
+    if "ingress_network_connectors" in value:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["ingressNetworkConnectors"] = (
+            capo_lambda_microvms.types.network_connector_list.serialize_json(
+                value["ingress_network_connectors"]
+            )
+        )
+    if "egress_network_connectors" in value:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["egressNetworkConnectors"] = (
+            capo_lambda_microvms.types.network_connector_list.serialize_json(
+                value["egress_network_connectors"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> RunMicrovmResponse:
+    out: RunMicrovmResponse = {}  # type: ignore[typeddict-item]
+    if data.get("microvmId") is not None:
+        out["microvm_id"] = data["microvmId"]
+    else:
+        raise DeserializationError("RunMicrovmResponse.microvm_id required")
+    if data.get("state") is not None:
+        import capo_lambda_microvms.types.microvm_state
+
+        out["state"] = capo_lambda_microvms.types.microvm_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("RunMicrovmResponse.state required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("RunMicrovmResponse.endpoint required")
+    if data.get("imageArn") is not None:
+        out["image_arn"] = data["imageArn"]
+    else:
+        raise DeserializationError("RunMicrovmResponse.image_arn required")
+    if data.get("imageVersion") is not None:
+        out["image_version"] = data["imageVersion"]
+    else:
+        raise DeserializationError("RunMicrovmResponse.image_version required")
+    if data.get("executionRoleArn") is not None:
+        out["execution_role_arn"] = data["executionRoleArn"]
+    if data.get("idlePolicy") is not None:
+        import capo_lambda_microvms.types.idle_policy
+
+        out["idle_policy"] = capo_lambda_microvms.types.idle_policy.deserialize_json(
+            data["idlePolicy"]
+        )
+    if data.get("maximumDurationInSeconds") is not None:
+        out["maximum_duration_in_seconds"] = data["maximumDurationInSeconds"]
+    else:
+        raise DeserializationError(
+            "RunMicrovmResponse.maximum_duration_in_seconds required"
+        )
+    if data.get("startedAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["started_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["startedAt"]
+            )
+        )
+    else:
+        raise DeserializationError("RunMicrovmResponse.started_at required")
+    if data.get("terminatedAt") is not None:
+        import capo_lambda_microvms.types._prelude.timestamp
+
+        out["terminated_at"] = (
+            capo_lambda_microvms.types._prelude.timestamp.deserialize_json(
+                data["terminatedAt"]
+            )
+        )
+    if data.get("stateReason") is not None:
+        out["state_reason"] = data["stateReason"]
+    if data.get("ingressNetworkConnectors") is not None:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["ingress_network_connectors"] = (
+            capo_lambda_microvms.types.network_connector_list.deserialize_json(
+                data["ingressNetworkConnectors"]
+            )
+        )
+    if data.get("egressNetworkConnectors") is not None:
+        import capo_lambda_microvms.types.network_connector_list
+
+        out["egress_network_connectors"] = (
+            capo_lambda_microvms.types.network_connector_list.deserialize_json(
+                data["egressNetworkConnectors"]
+            )
+        )
+    return out

capo_lambda_microvms/types/snapshot_build.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#SnapshotBuild``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class SnapshotBuild(TypedDict, closed=True):
+    memory_snapshot_size_in_bytes: NotRequired["int"]
+    """<p>The size of the memory snapshot in bytes.</p>"""
+    code_install_size_in_bytes: NotRequired["int"]
+    """<p>The size of the installed code in bytes.</p>"""
+    disk_snapshot_size_in_bytes: NotRequired["int"]
+    """<p>The size of the disk snapshot in bytes.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SnapshotBuild) -> dict:
+    out: dict = {}
+    if "memory_snapshot_size_in_bytes" in value:
+        out["memorySnapshotSizeInBytes"] = value["memory_snapshot_size_in_bytes"]
+    if "code_install_size_in_bytes" in value:
+        out["codeInstallSizeInBytes"] = value["code_install_size_in_bytes"]
+    if "disk_snapshot_size_in_bytes" in value:
+        out["diskSnapshotSizeInBytes"] = value["disk_snapshot_size_in_bytes"]
+    return out
+
+
+def deserialize_json(data: dict) -> SnapshotBuild:
+    out: SnapshotBuild = {}  # type: ignore[typeddict-item]
+    if data.get("memorySnapshotSizeInBytes") is not None:
+        out["memory_snapshot_size_in_bytes"] = data["memorySnapshotSizeInBytes"]
+    if data.get("codeInstallSizeInBytes") is not None:
+        out["code_install_size_in_bytes"] = data["codeInstallSizeInBytes"]
+    if data.get("diskSnapshotSizeInBytes") is not None:
+        out["disk_snapshot_size_in_bytes"] = data["diskSnapshotSizeInBytes"]
+    return out

capo_lambda_microvms/types/string.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#String``."""
+
+from typing import TypeAlias
+
+String: TypeAlias = str

capo_lambda_microvms/types/suspend_microvm_request.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#SuspendMicrovmRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_microvms.types.microvm_identifier
+
+
+class SuspendMicrovmRequest(TypedDict, closed=True):
+    microvm_identifier: (
+        "capo_lambda_microvms.types.microvm_identifier.MicrovmIdentifier"
+    )
+    """<p>The ID of the MicroVM to suspend.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SuspendMicrovmRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> SuspendMicrovmRequest:
+    out: SuspendMicrovmRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda_microvms/types/suspend_microvm_response.py

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

capo_lambda_microvms/types/tag_key.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdamicrovms#TagKey``."""
+
+from typing import TypeAlias
+
+TagKey: TypeAlias = str