capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/types/list_dev_environment_sessions_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListDevEnvironmentSessionsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.dev_environment_sessions_summary_list
+
+
+class ListDevEnvironmentSessionsResponse(TypedDict, closed=True):
+    items: "capo_codecatalyst.types.dev_environment_sessions_summary_list.DevEnvironmentSessionsSummaryList"
+    """<p>Information about each session retrieved in the list.</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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListDevEnvironmentSessionsResponse) -> dict:
+    out: dict = {}
+    import capo_codecatalyst.types.dev_environment_sessions_summary_list
+
+    out["items"] = (
+        capo_codecatalyst.types.dev_environment_sessions_summary_list.serialize_json(
+            value["items"]
+        )
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListDevEnvironmentSessionsResponse:
+    out: ListDevEnvironmentSessionsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.dev_environment_sessions_summary_list
+
+        out["items"] = (
+            capo_codecatalyst.types.dev_environment_sessions_summary_list.deserialize_json(
+                data["items"]
+            )
+        )
+    else:
+        raise DeserializationError("ListDevEnvironmentSessionsResponse.items required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecatalyst/types/list_dev_environments_request.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListDevEnvironmentsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.filters
+    import capo_codecatalyst.types.name_string
+
+
+class ListDevEnvironmentsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    project_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the project in the space.</p>"""
+    filters: NotRequired["capo_codecatalyst.types.filters.Filters"]
+    """<p>Information about filters to apply to narrow the results returned in the list.</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: ListDevEnvironmentsRequest) -> dict:
+    out: dict = {}
+    if "project_name" in value:
+        out["projectName"] = value["project_name"]
+    if "filters" in value:
+        import capo_codecatalyst.types.filters
+
+        out["filters"] = capo_codecatalyst.types.filters.serialize_json(
+            value["filters"]
+        )
+    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) -> ListDevEnvironmentsRequest:
+    out: ListDevEnvironmentsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("projectName") is not None:
+        out["project_name"] = data["projectName"]
+    if data.get("filters") is not None:
+        import capo_codecatalyst.types.filters
+
+        out["filters"] = capo_codecatalyst.types.filters.deserialize_json(
+            data["filters"]
+        )
+    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_dev_environments_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListDevEnvironmentsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.dev_environment_summary_list
+
+
+class ListDevEnvironmentsResponse(TypedDict, closed=True):
+    items: (
+        "capo_codecatalyst.types.dev_environment_summary_list.DevEnvironmentSummaryList"
+    )
+    """<p>Information about the Dev Environments in a project.</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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListDevEnvironmentsResponse) -> dict:
+    out: dict = {}
+    import capo_codecatalyst.types.dev_environment_summary_list
+
+    out["items"] = capo_codecatalyst.types.dev_environment_summary_list.serialize_json(
+        value["items"]
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListDevEnvironmentsResponse:
+    out: ListDevEnvironmentsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.dev_environment_summary_list
+
+        out["items"] = (
+            capo_codecatalyst.types.dev_environment_summary_list.deserialize_json(
+                data["items"]
+            )
+        )
+    else:
+        raise DeserializationError("ListDevEnvironmentsResponse.items required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecatalyst/types/list_event_logs_request.py

@@ -0,0 +1,75 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListEventLogsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.timestamp
+
+
+class ListEventLogsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of the space.</p>"""
+    start_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The date and time when you want to start retrieving events, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    end_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time after which you do not want any events retrieved, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    event_name: NotRequired["str"]
+    """<p>The name of the event.</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: ListEventLogsRequest) -> dict:
+    out: dict = {}
+    import capo_codecatalyst._protocol.serialize
+
+    out["startTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+        value["start_time"]
+    )
+    import capo_codecatalyst._protocol.serialize
+
+    out["endTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+        value["end_time"]
+    )
+    if "event_name" in value:
+        out["eventName"] = value["event_name"]
+    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) -> ListEventLogsRequest:
+    out: ListEventLogsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("startTime") is not None:
+        import datetime
+
+        out["start_time"] = datetime.datetime.fromisoformat(
+            data["startTime"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError("ListEventLogsRequest.start_time required")
+    if data.get("endTime") is not None:
+        import datetime
+
+        out["end_time"] = datetime.datetime.fromisoformat(
+            data["endTime"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError("ListEventLogsRequest.end_time required")
+    if data.get("eventName") is not None:
+        out["event_name"] = data["eventName"]
+    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_event_logs_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListEventLogsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.event_log_entries
+
+
+class ListEventLogsResponse(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.event_log_entries.EventLogEntries"
+    """<p>Information about each event retrieved in the list.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListEventLogsResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    import capo_codecatalyst.types.event_log_entries
+
+    out["items"] = capo_codecatalyst.types.event_log_entries.serialize_json(
+        value["items"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListEventLogsResponse:
+    out: ListEventLogsResponse = {}  # 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.event_log_entries
+
+        out["items"] = capo_codecatalyst.types.event_log_entries.deserialize_json(
+            data["items"]
+        )
+    else:
+        raise DeserializationError("ListEventLogsResponse.items required")
+    return out

capo_codecatalyst/types/list_projects_request.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListProjectsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.project_list_filters
+
+
+class ListProjectsRequest(TypedDict, closed=True):
+    space_name: "capo_codecatalyst.types.name_string.NameString"
+    """<p>The name of 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>"""
+    filters: NotRequired[
+        "capo_codecatalyst.types.project_list_filters.ProjectListFilters"
+    ]
+    """<p>Information about filters to apply to narrow the results returned in the list.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListProjectsRequest) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    if "filters" in value:
+        import capo_codecatalyst.types.project_list_filters
+
+        out["filters"] = capo_codecatalyst.types.project_list_filters.serialize_json(
+            value["filters"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListProjectsRequest:
+    out: ListProjectsRequest = {}  # 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"]
+    if data.get("filters") is not None:
+        import capo_codecatalyst.types.project_list_filters
+
+        out["filters"] = capo_codecatalyst.types.project_list_filters.deserialize_json(
+            data["filters"]
+        )
+    return out

capo_codecatalyst/types/list_projects_response.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListProjectsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.project_summaries
+
+
+class ListProjectsResponse(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.project_summaries.ProjectSummaries"]
+    """<p>Information about the projects.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListProjectsResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "items" in value:
+        import capo_codecatalyst.types.project_summaries
+
+        out["items"] = capo_codecatalyst.types.project_summaries.serialize_json(
+            value["items"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListProjectsResponse:
+    out: ListProjectsResponse = {}  # 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.project_summaries
+
+        out["items"] = capo_codecatalyst.types.project_summaries.deserialize_json(
+            data["items"]
+        )
+    return out

capo_codecatalyst/types/list_source_repositories_item.py

@@ -0,0 +1,81 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoriesItem``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.source_repository_description_string
+    import capo_codecatalyst.types.source_repository_id_string
+    import capo_codecatalyst.types.source_repository_name_string
+    import capo_codecatalyst.types.timestamp
+
+
+class ListSourceRepositoriesItem(TypedDict, closed=True):
+    id: "capo_codecatalyst.types.source_repository_id_string.SourceRepositoryIdString"
+    """<p>The system-generated unique ID of the source repository.</p>"""
+    name: "capo_codecatalyst.types.source_repository_name_string.SourceRepositoryNameString"
+    """<p>The name of the source repository.</p>"""
+    description: NotRequired[
+        "capo_codecatalyst.types.source_repository_description_string.SourceRepositoryDescriptionString"
+    ]
+    """<p>The description of the repository, if any.</p>"""
+    last_updated_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time the source repository was last updated, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    created_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time the source repository was created, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoriesItem) -> dict:
+    out: dict = {}
+    out["id"] = value["id"]
+    out["name"] = value["name"]
+    if "description" in value:
+        out["description"] = value["description"]
+    import capo_codecatalyst.types.timestamp
+
+    out["lastUpdatedTime"] = capo_codecatalyst.types.timestamp.serialize_json(
+        value["last_updated_time"]
+    )
+    import capo_codecatalyst.types.timestamp
+
+    out["createdTime"] = capo_codecatalyst.types.timestamp.serialize_json(
+        value["created_time"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListSourceRepositoriesItem:
+    out: ListSourceRepositoriesItem = {}  # type: ignore[typeddict-item]
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    else:
+        raise DeserializationError("ListSourceRepositoriesItem.id required")
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("ListSourceRepositoriesItem.name required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("lastUpdatedTime") is not None:
+        import capo_codecatalyst.types.timestamp
+
+        out["last_updated_time"] = capo_codecatalyst.types.timestamp.deserialize_json(
+            data["lastUpdatedTime"]
+        )
+    else:
+        raise DeserializationError(
+            "ListSourceRepositoriesItem.last_updated_time required"
+        )
+    if data.get("createdTime") is not None:
+        import capo_codecatalyst.types.timestamp
+
+        out["created_time"] = capo_codecatalyst.types.timestamp.deserialize_json(
+            data["createdTime"]
+        )
+    else:
+        raise DeserializationError("ListSourceRepositoriesItem.created_time required")
+    return out

capo_codecatalyst/types/list_source_repositories_items.py

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

capo_codecatalyst/types/list_source_repositories_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoriesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.name_string
+
+
+class ListSourceRepositoriesRequest(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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoriesRequest) -> 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) -> ListSourceRepositoriesRequest:
+    out: ListSourceRepositoriesRequest = {}  # 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_repositories_response.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoriesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.list_source_repositories_items
+
+
+class ListSourceRepositoriesResponse(TypedDict, closed=True):
+    items: NotRequired[
+        "capo_codecatalyst.types.list_source_repositories_items.ListSourceRepositoriesItems"
+    ]
+    """<p>Information about the source repositories.</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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoriesResponse) -> dict:
+    out: dict = {}
+    if "items" in value:
+        import capo_codecatalyst.types.list_source_repositories_items
+
+        out["items"] = (
+            capo_codecatalyst.types.list_source_repositories_items.serialize_json(
+                value["items"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListSourceRepositoriesResponse:
+    out: ListSourceRepositoriesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("items") is not None:
+        import capo_codecatalyst.types.list_source_repositories_items
+
+        out["items"] = (
+            capo_codecatalyst.types.list_source_repositories_items.deserialize_json(
+                data["items"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecatalyst/types/list_source_repository_branches_item.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ListSourceRepositoryBranchesItem``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.source_repository_branch_ref_string
+    import capo_codecatalyst.types.source_repository_branch_string
+    import capo_codecatalyst.types.timestamp
+
+
+class ListSourceRepositoryBranchesItem(TypedDict, closed=True):
+    ref: NotRequired[
+        "capo_codecatalyst.types.source_repository_branch_ref_string.SourceRepositoryBranchRefString"
+    ]
+    """<p>The Git reference name of the branch.</p>"""
+    name: NotRequired[
+        "capo_codecatalyst.types.source_repository_branch_string.SourceRepositoryBranchString"
+    ]
+    """<p>The name of the branch.</p>"""
+    last_updated_time: NotRequired["capo_codecatalyst.types.timestamp.Timestamp"]
+    r"""<p>The time the branch was last updated, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    head_commit_id: NotRequired["str"]
+    """<p>The commit ID of the tip of the branch at the time of the request, also known as the head commit.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListSourceRepositoryBranchesItem) -> dict:
+    out: dict = {}
+    if "ref" in value:
+        out["ref"] = value["ref"]
+    if "name" in value:
+        out["name"] = value["name"]
+    if "last_updated_time" in value:
+        import capo_codecatalyst._protocol.serialize
+
+        out["lastUpdatedTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+            value["last_updated_time"]
+        )
+    if "head_commit_id" in value:
+        out["headCommitId"] = value["head_commit_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListSourceRepositoryBranchesItem:
+    out: ListSourceRepositoryBranchesItem = {}  # type: ignore[typeddict-item]
+    if data.get("ref") is not None:
+        out["ref"] = data["ref"]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("lastUpdatedTime") is not None:
+        import datetime
+
+        out["last_updated_time"] = datetime.datetime.fromisoformat(
+            data["lastUpdatedTime"].replace("Z", "+00:00")
+        )
+    if data.get("headCommitId") is not None:
+        out["head_commit_id"] = data["headCommitId"]
+    return out