capo-workspaces 0.1.0__py3-none-any.whl

capo_workspaces/types/create_ip_group_request.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateIpGroupRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.ip_group_desc
+    import capo_workspaces.types.ip_group_name
+    import capo_workspaces.types.ip_rule_list
+    import capo_workspaces.types.tag_list
+
+
+class CreateIpGroupRequest(TypedDict, closed=True):
+    group_name: "capo_workspaces.types.ip_group_name.IpGroupName"
+    """<p>The name of the group.</p>"""
+    group_desc: NotRequired["capo_workspaces.types.ip_group_desc.IpGroupDesc"]
+    """<p>The description of the group.</p>"""
+    user_rules: NotRequired["capo_workspaces.types.ip_rule_list.IpRuleList"]
+    """<p>The rules to add to the group.</p>"""
+    tags: NotRequired["capo_workspaces.types.tag_list.TagList"]
+    """<p>The tags. Each WorkSpaces resource can have a maximum of 50 tags.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateIpGroupRequest) -> dict:
+    out: dict = {}
+    out["GroupName"] = value["group_name"]
+    if "group_desc" in value:
+        out["GroupDesc"] = value["group_desc"]
+    if "user_rules" in value:
+        import capo_workspaces.types.ip_rule_list
+
+        out["UserRules"] = capo_workspaces.types.ip_rule_list.serialize_aws_json_1_1(
+            value["user_rules"]
+        )
+    if "tags" in value:
+        import capo_workspaces.types.tag_list
+
+        out["Tags"] = capo_workspaces.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateIpGroupRequest:
+    out: CreateIpGroupRequest = {}  # type: ignore[typeddict-item]
+    if data.get("GroupName") is not None:
+        out["group_name"] = data["GroupName"]
+    else:
+        raise DeserializationError("CreateIpGroupRequest.group_name required")
+    if data.get("GroupDesc") is not None:
+        out["group_desc"] = data["GroupDesc"]
+    if data.get("UserRules") is not None:
+        import capo_workspaces.types.ip_rule_list
+
+        out["user_rules"] = capo_workspaces.types.ip_rule_list.deserialize_aws_json_1_1(
+            data["UserRules"]
+        )
+    if data.get("Tags") is not None:
+        import capo_workspaces.types.tag_list
+
+        out["tags"] = capo_workspaces.types.tag_list.deserialize_aws_json_1_1(
+            data["Tags"]
+        )
+    return out

capo_workspaces/types/create_ip_group_result.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateIpGroupResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.ip_group_id
+
+
+class CreateIpGroupResult(TypedDict, closed=True):
+    group_id: NotRequired["capo_workspaces.types.ip_group_id.IpGroupId"]
+    """<p>The identifier of the group.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateIpGroupResult) -> dict:
+    out: dict = {}
+    if "group_id" in value:
+        out["GroupId"] = value["group_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateIpGroupResult:
+    out: CreateIpGroupResult = {}  # type: ignore[typeddict-item]
+    if data.get("GroupId") is not None:
+        out["group_id"] = data["GroupId"]
+    return out

capo_workspaces/types/create_standby_workspaces_request.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateStandbyWorkspacesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.region
+    import capo_workspaces.types.standby_workspaces_list
+
+
+class CreateStandbyWorkspacesRequest(TypedDict, closed=True):
+    primary_region: "capo_workspaces.types.region.Region"
+    """<p>The Region of the primary WorkSpace.</p>"""
+    standby_workspaces: (
+        "capo_workspaces.types.standby_workspaces_list.StandbyWorkspacesList"
+    )
+    """<p>Information about the standby WorkSpace to be created.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateStandbyWorkspacesRequest) -> dict:
+    out: dict = {}
+    out["PrimaryRegion"] = value["primary_region"]
+    import capo_workspaces.types.standby_workspaces_list
+
+    out["StandbyWorkspaces"] = (
+        capo_workspaces.types.standby_workspaces_list.serialize_aws_json_1_1(
+            value["standby_workspaces"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateStandbyWorkspacesRequest:
+    out: CreateStandbyWorkspacesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("PrimaryRegion") is not None:
+        out["primary_region"] = data["PrimaryRegion"]
+    else:
+        raise DeserializationError(
+            "CreateStandbyWorkspacesRequest.primary_region required"
+        )
+    if data.get("StandbyWorkspaces") is not None:
+        import capo_workspaces.types.standby_workspaces_list
+
+        out["standby_workspaces"] = (
+            capo_workspaces.types.standby_workspaces_list.deserialize_aws_json_1_1(
+                data["StandbyWorkspaces"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateStandbyWorkspacesRequest.standby_workspaces required"
+        )
+    return out

capo_workspaces/types/create_standby_workspaces_result.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateStandbyWorkspacesResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.failed_create_standby_workspaces_request_list
+    import capo_workspaces.types.pending_create_standby_workspaces_request_list
+
+
+class CreateStandbyWorkspacesResult(TypedDict, closed=True):
+    failed_standby_requests: NotRequired[
+        "capo_workspaces.types.failed_create_standby_workspaces_request_list.FailedCreateStandbyWorkspacesRequestList"
+    ]
+    """<p>Information about the standby WorkSpace that could not be created. </p>"""
+    pending_standby_requests: NotRequired[
+        "capo_workspaces.types.pending_create_standby_workspaces_request_list.PendingCreateStandbyWorkspacesRequestList"
+    ]
+    """<p>Information about the standby WorkSpace that was created.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateStandbyWorkspacesResult) -> dict:
+    out: dict = {}
+    if "failed_standby_requests" in value:
+        import capo_workspaces.types.failed_create_standby_workspaces_request_list
+
+        out["FailedStandbyRequests"] = (
+            capo_workspaces.types.failed_create_standby_workspaces_request_list.serialize_aws_json_1_1(
+                value["failed_standby_requests"]
+            )
+        )
+    if "pending_standby_requests" in value:
+        import capo_workspaces.types.pending_create_standby_workspaces_request_list
+
+        out["PendingStandbyRequests"] = (
+            capo_workspaces.types.pending_create_standby_workspaces_request_list.serialize_aws_json_1_1(
+                value["pending_standby_requests"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateStandbyWorkspacesResult:
+    out: CreateStandbyWorkspacesResult = {}  # type: ignore[typeddict-item]
+    if data.get("FailedStandbyRequests") is not None:
+        import capo_workspaces.types.failed_create_standby_workspaces_request_list
+
+        out["failed_standby_requests"] = (
+            capo_workspaces.types.failed_create_standby_workspaces_request_list.deserialize_aws_json_1_1(
+                data["FailedStandbyRequests"]
+            )
+        )
+    if data.get("PendingStandbyRequests") is not None:
+        import capo_workspaces.types.pending_create_standby_workspaces_request_list
+
+        out["pending_standby_requests"] = (
+            capo_workspaces.types.pending_create_standby_workspaces_request_list.deserialize_aws_json_1_1(
+                data["PendingStandbyRequests"]
+            )
+        )
+    return out

capo_workspaces/types/create_tags_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateTagsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.non_empty_string
+    import capo_workspaces.types.tag_list
+
+
+class CreateTagsRequest(TypedDict, closed=True):
+    resource_id: "capo_workspaces.types.non_empty_string.NonEmptyString"
+    """<p>The identifier of the WorkSpaces resource. The supported resource types are WorkSpaces, registered directories, images, custom bundles, IP access control groups, and connection aliases.</p>"""
+    tags: "capo_workspaces.types.tag_list.TagList"
+    """<p>The tags. Each WorkSpaces resource can have a maximum of 50 tags.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateTagsRequest) -> dict:
+    out: dict = {}
+    out["ResourceId"] = value["resource_id"]
+    import capo_workspaces.types.tag_list
+
+    out["Tags"] = capo_workspaces.types.tag_list.serialize_aws_json_1_1(value["tags"])
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateTagsRequest:
+    out: CreateTagsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("ResourceId") is not None:
+        out["resource_id"] = data["ResourceId"]
+    else:
+        raise DeserializationError("CreateTagsRequest.resource_id required")
+    if data.get("Tags") is not None:
+        import capo_workspaces.types.tag_list
+
+        out["tags"] = capo_workspaces.types.tag_list.deserialize_aws_json_1_1(
+            data["Tags"]
+        )
+    else:
+        raise DeserializationError("CreateTagsRequest.tags required")
+    return out

capo_workspaces/types/create_tags_result.py

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

capo_workspaces/types/create_updated_workspace_image_request.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateUpdatedWorkspaceImageRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.tag_list
+    import capo_workspaces.types.workspace_image_description
+    import capo_workspaces.types.workspace_image_id
+    import capo_workspaces.types.workspace_image_name
+
+
+class CreateUpdatedWorkspaceImageRequest(TypedDict, closed=True):
+    name: "capo_workspaces.types.workspace_image_name.WorkspaceImageName"
+    """<p>The name of the new updated WorkSpace image.</p>"""
+    description: (
+        "capo_workspaces.types.workspace_image_description.WorkspaceImageDescription"
+    )
+    """<p>A description of whether updates for the WorkSpace image are available.</p>"""
+    source_image_id: "capo_workspaces.types.workspace_image_id.WorkspaceImageId"
+    """<p>The identifier of the source WorkSpace image.</p>"""
+    tags: NotRequired["capo_workspaces.types.tag_list.TagList"]
+    """<p>The tags that you want to add to the new updated WorkSpace image.</p> <note> <p>To add tags at the same time when you're creating the updated image, you must create an IAM policy that grants your IAM user permissions to use <code>workspaces:CreateTags</code>. </p> </note>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateUpdatedWorkspaceImageRequest) -> dict:
+    out: dict = {}
+    out["Name"] = value["name"]
+    out["Description"] = value["description"]
+    out["SourceImageId"] = value["source_image_id"]
+    if "tags" in value:
+        import capo_workspaces.types.tag_list
+
+        out["Tags"] = capo_workspaces.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateUpdatedWorkspaceImageRequest:
+    out: CreateUpdatedWorkspaceImageRequest = {}  # type: ignore[typeddict-item]
+    if data.get("Name") is not None:
+        out["name"] = data["Name"]
+    else:
+        raise DeserializationError("CreateUpdatedWorkspaceImageRequest.name required")
+    if data.get("Description") is not None:
+        out["description"] = data["Description"]
+    else:
+        raise DeserializationError(
+            "CreateUpdatedWorkspaceImageRequest.description required"
+        )
+    if data.get("SourceImageId") is not None:
+        out["source_image_id"] = data["SourceImageId"]
+    else:
+        raise DeserializationError(
+            "CreateUpdatedWorkspaceImageRequest.source_image_id required"
+        )
+    if data.get("Tags") is not None:
+        import capo_workspaces.types.tag_list
+
+        out["tags"] = capo_workspaces.types.tag_list.deserialize_aws_json_1_1(
+            data["Tags"]
+        )
+    return out

capo_workspaces/types/create_updated_workspace_image_result.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateUpdatedWorkspaceImageResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.workspace_image_id
+
+
+class CreateUpdatedWorkspaceImageResult(TypedDict, closed=True):
+    image_id: NotRequired["capo_workspaces.types.workspace_image_id.WorkspaceImageId"]
+    """<p>The identifier of the new updated WorkSpace image.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateUpdatedWorkspaceImageResult) -> dict:
+    out: dict = {}
+    if "image_id" in value:
+        out["ImageId"] = value["image_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateUpdatedWorkspaceImageResult:
+    out: CreateUpdatedWorkspaceImageResult = {}  # type: ignore[typeddict-item]
+    if data.get("ImageId") is not None:
+        out["image_id"] = data["ImageId"]
+    return out

capo_workspaces/types/create_workspace_bundle_request.py

@@ -0,0 +1,116 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateWorkspaceBundleRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.compute_type
+    import capo_workspaces.types.root_storage
+    import capo_workspaces.types.tag_list
+    import capo_workspaces.types.user_storage
+    import capo_workspaces.types.workspace_bundle_description
+    import capo_workspaces.types.workspace_bundle_name
+    import capo_workspaces.types.workspace_image_id
+
+
+class CreateWorkspaceBundleRequest(TypedDict, closed=True):
+    bundle_name: "capo_workspaces.types.workspace_bundle_name.WorkspaceBundleName"
+    """<p>The name of the bundle.</p>"""
+    bundle_description: (
+        "capo_workspaces.types.workspace_bundle_description.WorkspaceBundleDescription"
+    )
+    """<p>The description of the bundle.</p>"""
+    image_id: "capo_workspaces.types.workspace_image_id.WorkspaceImageId"
+    """<p>The identifier of the image that is used to create the bundle.</p>"""
+    compute_type: "capo_workspaces.types.compute_type.ComputeType"
+    user_storage: "capo_workspaces.types.user_storage.UserStorage"
+    root_storage: NotRequired["capo_workspaces.types.root_storage.RootStorage"]
+    tags: NotRequired["capo_workspaces.types.tag_list.TagList"]
+    """<p>The tags associated with the bundle.</p> <note> <p>To add tags at the same time when you're creating the bundle, you must create an IAM policy that grants your IAM user permissions to use <code>workspaces:CreateTags</code>. </p> </note>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateWorkspaceBundleRequest) -> dict:
+    out: dict = {}
+    out["BundleName"] = value["bundle_name"]
+    out["BundleDescription"] = value["bundle_description"]
+    out["ImageId"] = value["image_id"]
+    import capo_workspaces.types.compute_type
+
+    out["ComputeType"] = capo_workspaces.types.compute_type.serialize_aws_json_1_1(
+        value["compute_type"]
+    )
+    import capo_workspaces.types.user_storage
+
+    out["UserStorage"] = capo_workspaces.types.user_storage.serialize_aws_json_1_1(
+        value["user_storage"]
+    )
+    if "root_storage" in value:
+        import capo_workspaces.types.root_storage
+
+        out["RootStorage"] = capo_workspaces.types.root_storage.serialize_aws_json_1_1(
+            value["root_storage"]
+        )
+    if "tags" in value:
+        import capo_workspaces.types.tag_list
+
+        out["Tags"] = capo_workspaces.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateWorkspaceBundleRequest:
+    out: CreateWorkspaceBundleRequest = {}  # type: ignore[typeddict-item]
+    if data.get("BundleName") is not None:
+        out["bundle_name"] = data["BundleName"]
+    else:
+        raise DeserializationError("CreateWorkspaceBundleRequest.bundle_name required")
+    if data.get("BundleDescription") is not None:
+        out["bundle_description"] = data["BundleDescription"]
+    else:
+        raise DeserializationError(
+            "CreateWorkspaceBundleRequest.bundle_description required"
+        )
+    if data.get("ImageId") is not None:
+        out["image_id"] = data["ImageId"]
+    else:
+        raise DeserializationError("CreateWorkspaceBundleRequest.image_id required")
+    if data.get("ComputeType") is not None:
+        import capo_workspaces.types.compute_type
+
+        out["compute_type"] = (
+            capo_workspaces.types.compute_type.deserialize_aws_json_1_1(
+                data["ComputeType"]
+            )
+        )
+    else:
+        raise DeserializationError("CreateWorkspaceBundleRequest.compute_type required")
+    if data.get("UserStorage") is not None:
+        import capo_workspaces.types.user_storage
+
+        out["user_storage"] = (
+            capo_workspaces.types.user_storage.deserialize_aws_json_1_1(
+                data["UserStorage"]
+            )
+        )
+    else:
+        raise DeserializationError("CreateWorkspaceBundleRequest.user_storage required")
+    if data.get("RootStorage") is not None:
+        import capo_workspaces.types.root_storage
+
+        out["root_storage"] = (
+            capo_workspaces.types.root_storage.deserialize_aws_json_1_1(
+                data["RootStorage"]
+            )
+        )
+    if data.get("Tags") is not None:
+        import capo_workspaces.types.tag_list
+
+        out["tags"] = capo_workspaces.types.tag_list.deserialize_aws_json_1_1(
+            data["Tags"]
+        )
+    return out

capo_workspaces/types/create_workspace_bundle_result.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateWorkspaceBundleResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.workspace_bundle
+
+
+class CreateWorkspaceBundleResult(TypedDict, closed=True):
+    workspace_bundle: NotRequired[
+        "capo_workspaces.types.workspace_bundle.WorkspaceBundle"
+    ]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateWorkspaceBundleResult) -> dict:
+    out: dict = {}
+    if "workspace_bundle" in value:
+        import capo_workspaces.types.workspace_bundle
+
+        out["WorkspaceBundle"] = (
+            capo_workspaces.types.workspace_bundle.serialize_aws_json_1_1(
+                value["workspace_bundle"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateWorkspaceBundleResult:
+    out: CreateWorkspaceBundleResult = {}  # type: ignore[typeddict-item]
+    if data.get("WorkspaceBundle") is not None:
+        import capo_workspaces.types.workspace_bundle
+
+        out["workspace_bundle"] = (
+            capo_workspaces.types.workspace_bundle.deserialize_aws_json_1_1(
+                data["WorkspaceBundle"]
+            )
+        )
+    return out

capo_workspaces/types/create_workspace_image_request.py

@@ -0,0 +1,64 @@
+"""Generated from Smithy shape ``com.amazonaws.workspaces#CreateWorkspaceImageRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_workspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_workspaces.types.tag_list
+    import capo_workspaces.types.workspace_id
+    import capo_workspaces.types.workspace_image_description
+    import capo_workspaces.types.workspace_image_name
+
+
+class CreateWorkspaceImageRequest(TypedDict, closed=True):
+    name: "capo_workspaces.types.workspace_image_name.WorkspaceImageName"
+    """<p>The name of the new WorkSpace image.</p>"""
+    description: (
+        "capo_workspaces.types.workspace_image_description.WorkspaceImageDescription"
+    )
+    """<p>The description of the new WorkSpace image.</p>"""
+    workspace_id: "capo_workspaces.types.workspace_id.WorkspaceId"
+    """<p>The identifier of the source WorkSpace</p>"""
+    tags: NotRequired["capo_workspaces.types.tag_list.TagList"]
+    """<p>The tags that you want to add to the new WorkSpace image. To add tags when you're creating the image, you must create an IAM policy that grants your IAM user permission to use <code>workspaces:CreateTags</code>.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CreateWorkspaceImageRequest) -> dict:
+    out: dict = {}
+    out["Name"] = value["name"]
+    out["Description"] = value["description"]
+    out["WorkspaceId"] = value["workspace_id"]
+    if "tags" in value:
+        import capo_workspaces.types.tag_list
+
+        out["Tags"] = capo_workspaces.types.tag_list.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> CreateWorkspaceImageRequest:
+    out: CreateWorkspaceImageRequest = {}  # type: ignore[typeddict-item]
+    if data.get("Name") is not None:
+        out["name"] = data["Name"]
+    else:
+        raise DeserializationError("CreateWorkspaceImageRequest.name required")
+    if data.get("Description") is not None:
+        out["description"] = data["Description"]
+    else:
+        raise DeserializationError("CreateWorkspaceImageRequest.description required")
+    if data.get("WorkspaceId") is not None:
+        out["workspace_id"] = data["WorkspaceId"]
+    else:
+        raise DeserializationError("CreateWorkspaceImageRequest.workspace_id required")
+    if data.get("Tags") is not None:
+        import capo_workspaces.types.tag_list
+
+        out["tags"] = capo_workspaces.types.tag_list.deserialize_aws_json_1_1(
+            data["Tags"]
+        )
+    return out