capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/types/list_source_repository_branches_items.py

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

capo_codecatalyst/types/list_source_repository_branches_request.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoryBranchesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.source_repository_name_string
+
+
+class ListSourceRepositoryBranchesRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    source_repository_name: "capo_codecatalyst.types.source_repository_name_string.SourceRepositoryNameString"
+    """<p>The name of the source repository.</p>"""
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    max_results: NotRequired["int"]
+    """<p>The maximum number of results to show in a single call to this API. If the number of results is larger than the number you specified, the response will include a <code>NextToken</code> element, which you can use to obtain additional results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoryBranchesRequest) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListSourceRepositoryBranchesRequest:
+    out: ListSourceRepositoryBranchesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    return out

capo_codecatalyst/types/list_source_repository_branches_response.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoryBranchesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.list_source_repository_branches_items
+
+
+class ListSourceRepositoryBranchesResponse(TypedDict, closed=True):
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    items: "capo_codecatalyst.types.list_source_repository_branches_items.ListSourceRepositoryBranchesItems"
+    """<p>Information about the source branches.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoryBranchesResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    import capo_codecatalyst.types.list_source_repository_branches_items
+
+    out["items"] = (
+        capo_codecatalyst.types.list_source_repository_branches_items.serialize_json(
+            value["items"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListSourceRepositoryBranchesResponse:
+    out: ListSourceRepositoryBranchesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.list_source_repository_branches_items
+
+        out["items"] = (
+            capo_codecatalyst.types.list_source_repository_branches_items.deserialize_json(
+                data["items"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListSourceRepositoryBranchesResponse.items required"
+        )
+    return out

capo_codecatalyst/types/list_spaces_request.py

@@ -0,0 +1,23 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSpacesRequest``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class ListSpacesRequest(TypedDict, closed=True):
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSpacesRequest) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListSpacesRequest:
+    out: ListSpacesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecatalyst/types/list_spaces_response.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSpacesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.space_summaries
+
+
+class ListSpacesResponse(TypedDict, closed=True):
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    items: NotRequired["capo_codecatalyst.types.space_summaries.SpaceSummaries"]
+    """<p>Information about the spaces. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSpacesResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "items" in value:
+        import capo_codecatalyst.types.space_summaries
+
+        out["items"] = capo_codecatalyst.types.space_summaries.serialize_json(
+            value["items"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListSpacesResponse:
+    out: ListSpacesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.space_summaries
+
+        out["items"] = capo_codecatalyst.types.space_summaries.deserialize_json(
+            data["items"]
+        )
+    return out

capo_codecatalyst/types/list_workflow_runs_request.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListWorkflowRunsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.uuid
+    import capo_codecatalyst.types.workflow_run_sort_criteria_list
+
+
+class ListWorkflowRunsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    workflow_id: NotRequired["capo_codecatalyst.types.uuid.Uuid"]
+    """<p>The ID of the workflow. To retrieve a list of workflow IDs, use <a>ListWorkflows</a>.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    max_results: NotRequired["int"]
+    """<p>The maximum number of results to show in a single call to this API. If the number of results is larger than the number you specified, the response will include a <code>NextToken</code> element, which you can use to obtain additional results.</p>"""
+    sort_by: NotRequired[
+        "capo_codecatalyst.types.workflow_run_sort_criteria_list.WorkflowRunSortCriteriaList"
+    ]
+    """<p>Information used to sort the items in the returned list.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWorkflowRunsRequest) -> dict:
+    out: dict = {}
+    if "sort_by" in value:
+        import capo_codecatalyst.types.workflow_run_sort_criteria_list
+
+        out["sortBy"] = (
+            capo_codecatalyst.types.workflow_run_sort_criteria_list.serialize_json(
+                value["sort_by"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListWorkflowRunsRequest:
+    out: ListWorkflowRunsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("sortBy") is not None:
+        import capo_codecatalyst.types.workflow_run_sort_criteria_list
+
+        out["sort_by"] = (
+            capo_codecatalyst.types.workflow_run_sort_criteria_list.deserialize_json(
+                data["sortBy"]
+            )
+        )
+    return out

capo_codecatalyst/types/list_workflow_runs_response.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListWorkflowRunsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.workflow_run_summaries
+
+
+class ListWorkflowRunsResponse(TypedDict, closed=True):
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    items: NotRequired[
+        "capo_codecatalyst.types.workflow_run_summaries.WorkflowRunSummaries"
+    ]
+    """<p>Information about the runs of a workflow.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWorkflowRunsResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "items" in value:
+        import capo_codecatalyst.types.workflow_run_summaries
+
+        out["items"] = capo_codecatalyst.types.workflow_run_summaries.serialize_json(
+            value["items"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListWorkflowRunsResponse:
+    out: ListWorkflowRunsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.workflow_run_summaries
+
+        out["items"] = capo_codecatalyst.types.workflow_run_summaries.deserialize_json(
+            data["items"]
+        )
+    return out

capo_codecatalyst/types/list_workflows_request.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListWorkflowsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.workflow_sort_criteria_list
+
+
+class ListWorkflowsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the project in the space.</p>"""
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    max_results: NotRequired["int"]
+    """<p>The maximum number of results to show in a single call to this API. If the number of results is larger than the number you specified, the response will include a <code>NextToken</code> element, which you can use to obtain additional results.</p>"""
+    sort_by: NotRequired[
+        "capo_codecatalyst.types.workflow_sort_criteria_list.WorkflowSortCriteriaList"
+    ]
+    """<p>Information used to sort the items in the returned list.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWorkflowsRequest) -> dict:
+    out: dict = {}
+    if "sort_by" in value:
+        import capo_codecatalyst.types.workflow_sort_criteria_list
+
+        out["sortBy"] = (
+            capo_codecatalyst.types.workflow_sort_criteria_list.serialize_json(
+                value["sort_by"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListWorkflowsRequest:
+    out: ListWorkflowsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("sortBy") is not None:
+        import capo_codecatalyst.types.workflow_sort_criteria_list
+
+        out["sort_by"] = (
+            capo_codecatalyst.types.workflow_sort_criteria_list.deserialize_json(
+                data["sortBy"]
+            )
+        )
+    return out

capo_codecatalyst/types/list_workflows_response.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListWorkflowsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.workflow_summaries
+
+
+class ListWorkflowsResponse(TypedDict, closed=True):
+    next_token: NotRequired["str"]
+    """<p>A token returned from a call to this API to indicate the next batch of results to return, if any.</p>"""
+    items: NotRequired["capo_codecatalyst.types.workflow_summaries.WorkflowSummaries"]
+    """<p>Information about the workflows in a project.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWorkflowsResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "items" in value:
+        import capo_codecatalyst.types.workflow_summaries
+
+        out["items"] = capo_codecatalyst.types.workflow_summaries.serialize_json(
+            value["items"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListWorkflowsResponse:
+    out: ListWorkflowsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.workflow_summaries
+
+        out["items"] = capo_codecatalyst.types.workflow_summaries.deserialize_json(
+            data["items"]
+        )
+    return out

capo_codecatalyst/types/name_string.py

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

capo_codecatalyst/types/operation_type.py

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

capo_codecatalyst/types/persistent_storage.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#PersistentStorage``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+
+class PersistentStorage(TypedDict, closed=True):
+    size_in_gi_b: "int"
+    """<p>The size of the persistent storage in gigabytes (specifically GiB).</p> <note> <p>Valid values for storage are based on memory sizes in 16GB increments. Valid values are 16, 32, and 64.</p> </note>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PersistentStorage) -> dict:
+    out: dict = {}
+    out["sizeInGiB"] = value["size_in_gi_b"]
+    return out
+
+
+def deserialize_json(data: dict) -> PersistentStorage:
+    out: PersistentStorage = {}  # type: ignore[typeddict-item]
+    if data.get("sizeInGiB") is not None:
+        out["size_in_gi_b"] = data["sizeInGiB"]
+    else:
+        raise DeserializationError("PersistentStorage.size_in_gi_b required")
+    return out

capo_codecatalyst/types/persistent_storage_configuration.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#PersistentStorageConfiguration``."""
+
+from typing_extensions import TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+
+class PersistentStorageConfiguration(TypedDict, closed=True):
+    size_in_gi_b: "int"
+    """<p>The size of the persistent storage in gigabytes (specifically GiB).</p> <note> <p>Valid values for storage are based on memory sizes in 16GB increments. Valid values are 16, 32, and 64.</p> </note>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PersistentStorageConfiguration) -> dict:
+    out: dict = {}
+    out["sizeInGiB"] = value["size_in_gi_b"]
+    return out
+
+
+def deserialize_json(data: dict) -> PersistentStorageConfiguration:
+    out: PersistentStorageConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("sizeInGiB") is not None:
+        out["size_in_gi_b"] = data["sizeInGiB"]
+    else:
+        raise DeserializationError(
+            "PersistentStorageConfiguration.size_in_gi_b required"
+        )
+    return out

capo_codecatalyst/types/project_description.py

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

capo_codecatalyst/types/project_display_name.py

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

capo_codecatalyst/types/project_information.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ProjectInformation``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class ProjectInformation(TypedDict, closed=True):
+    name: NotRequired["str"]
+    """<p>The name of the project in the space.</p>"""
+    project_id: NotRequired["str"]
+    """<p>The system-generated unique ID of the project.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProjectInformation) -> dict:
+    out: dict = {}
+    if "name" in value:
+        out["name"] = value["name"]
+    if "project_id" in value:
+        out["projectId"] = value["project_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProjectInformation:
+    out: ProjectInformation = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("projectId") is not None:
+        out["project_id"] = data["projectId"]
+    return out

capo_codecatalyst/types/project_list_filter.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ProjectListFilter``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.comparison_operator
+    import capo_codecatalyst.types.filter_key
+    import capo_codecatalyst.types.string_list
+
+
+class ProjectListFilter(TypedDict, closed=True):
+    key: "capo_codecatalyst.types.filter_key.FilterKey"
+    """<p>A key that can be used to sort results.</p>"""
+    values: "capo_codecatalyst.types.string_list.StringList"
+    """<p>The values of the key.</p>"""
+    comparison_operator: NotRequired[
+        "capo_codecatalyst.types.comparison_operator.ComparisonOperator"
+    ]
+    """<p>The operator used to compare the fields.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProjectListFilter) -> dict:
+    out: dict = {}
+    out["key"] = value["key"]
+    import capo_codecatalyst.types.string_list
+
+    out["values"] = capo_codecatalyst.types.string_list.serialize_json(value["values"])
+    if "comparison_operator" in value:
+        out["comparisonOperator"] = value["comparison_operator"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProjectListFilter:
+    out: ProjectListFilter = {}  # type: ignore[typeddict-item]
+    if data.get("key") is not None:
+        out["key"] = data["key"]
+    else:
+        raise DeserializationError("ProjectListFilter.key required")
+    if data.get("values") is not None:
+        import capo_codecatalyst.types.string_list
+
+        out["values"] = capo_codecatalyst.types.string_list.deserialize_json(
+            data["values"]
+        )
+    else:
+        raise DeserializationError("ProjectListFilter.values required")
+    if data.get("comparisonOperator") is not None:
+        out["comparison_operator"] = data["comparisonOperator"]
+    return out

capo_codecatalyst/types/project_list_filters.py

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

capo_codecatalyst/types/project_summaries.py

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

capo_codecatalyst/types/project_summary.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ProjectSummary``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+
+class ProjectSummary(TypedDict, closed=True):
+    name: "str"
+    """<p>The name of the project in the space.</p>"""
+    display_name: NotRequired["str"]
+    """<p>The friendly name displayed to users of the project in Amazon CodeCatalyst.</p>"""
+    description: NotRequired["str"]
+    """<p>The description of the project.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProjectSummary) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    if "display_name" in value:
+        out["displayName"] = value["display_name"]
+    if "description" in value:
+        out["description"] = value["description"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProjectSummary:
+    out: ProjectSummary = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("ProjectSummary.name required")
+    if data.get("displayName") is not None:
+        out["display_name"] = data["displayName"]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    return out