capo-codecommit 0.1.0__py3-none-any.whl

capo_codecommit/types/batch_disassociate_approval_rule_template_from_repositories_output.py

@@ -0,0 +1,75 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list
+    import capo_codecommit.types.repository_name_list
+
+
+class BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput(
+    TypedDict, closed=True
+):
+    disassociated_repository_names: (
+        "capo_codecommit.types.repository_name_list.RepositoryNameList"
+    )
+    """<p>A list of repository names that have had their association with the template removed.</p>"""
+    errors: "capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list.BatchDisassociateApprovalRuleTemplateFromRepositoriesErrorsList"
+    """<p>A list of any errors that might have occurred while attempting to remove the association between the template and the repositories.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(
+    value: BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput,
+) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.repository_name_list
+
+    out["disassociatedRepositoryNames"] = (
+        capo_codecommit.types.repository_name_list.serialize_aws_json_1_1(
+            value["disassociated_repository_names"]
+        )
+    )
+    import capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list
+
+    out["errors"] = (
+        capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list.serialize_aws_json_1_1(
+            value["errors"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(
+    data: dict,
+) -> BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput:
+    out: BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput = {}  # type: ignore[typeddict-item]
+    if data.get("disassociatedRepositoryNames") is not None:
+        import capo_codecommit.types.repository_name_list
+
+        out["disassociated_repository_names"] = (
+            capo_codecommit.types.repository_name_list.deserialize_aws_json_1_1(
+                data["disassociatedRepositoryNames"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput.disassociated_repository_names required"
+        )
+    if data.get("errors") is not None:
+        import capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list
+
+        out["errors"] = (
+            capo_codecommit.types.batch_disassociate_approval_rule_template_from_repositories_errors_list.deserialize_aws_json_1_1(
+                data["errors"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput.errors required"
+        )
+    return out

capo_codecommit/types/batch_get_commits_error.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetCommitsError``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.error_code
+    import capo_codecommit.types.error_message
+    import capo_codecommit.types.object_id
+
+
+class BatchGetCommitsError(TypedDict, closed=True):
+    commit_id: NotRequired["capo_codecommit.types.object_id.ObjectId"]
+    """<p>A commit ID that either could not be found or was not in a valid format.</p>"""
+    error_code: NotRequired["capo_codecommit.types.error_code.ErrorCode"]
+    """<p>An error code that specifies whether the commit ID was not valid or not found.</p>"""
+    error_message: NotRequired["capo_codecommit.types.error_message.ErrorMessage"]
+    """<p>An error message that provides detail about why the commit ID either was not found or was not valid.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetCommitsError) -> dict:
+    out: dict = {}
+    if "commit_id" in value:
+        out["commitId"] = value["commit_id"]
+    if "error_code" in value:
+        out["errorCode"] = value["error_code"]
+    if "error_message" in value:
+        out["errorMessage"] = value["error_message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetCommitsError:
+    out: BatchGetCommitsError = {}  # type: ignore[typeddict-item]
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    if data.get("errorCode") is not None:
+        out["error_code"] = data["errorCode"]
+    if data.get("errorMessage") is not None:
+        out["error_message"] = data["errorMessage"]
+    return out

capo_codecommit/types/batch_get_commits_errors_list.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetCommitsErrorsList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_get_commits_error
+
+BatchGetCommitsErrorsList: TypeAlias = list[
+    "capo_codecommit.types.batch_get_commits_error.BatchGetCommitsError"
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetCommitsErrorsList) -> list:
+    import capo_codecommit.types.batch_get_commits_error
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codecommit.types.batch_get_commits_error.serialize_aws_json_1_1(item)
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: list) -> BatchGetCommitsErrorsList:
+    import capo_codecommit.types.batch_get_commits_error
+
+    out: BatchGetCommitsErrorsList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codecommit.types.batch_get_commits_error.deserialize_aws_json_1_1(item)
+        )
+    return out

capo_codecommit/types/batch_get_commits_input.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetCommitsInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit_ids_input_list
+    import capo_codecommit.types.repository_name
+
+
+class BatchGetCommitsInput(TypedDict, closed=True):
+    commit_ids: "capo_codecommit.types.commit_ids_input_list.CommitIdsInputList"
+    """<p>The full commit IDs of the commits to get information about.</p> <note> <p>You must supply the full SHA IDs of each commit. You cannot use shortened SHA IDs.</p> </note>"""
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository that contains the commits.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetCommitsInput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.commit_ids_input_list
+
+    out["commitIds"] = (
+        capo_codecommit.types.commit_ids_input_list.serialize_aws_json_1_1(
+            value["commit_ids"]
+        )
+    )
+    out["repositoryName"] = value["repository_name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetCommitsInput:
+    out: BatchGetCommitsInput = {}  # type: ignore[typeddict-item]
+    if data.get("commitIds") is not None:
+        import capo_codecommit.types.commit_ids_input_list
+
+        out["commit_ids"] = (
+            capo_codecommit.types.commit_ids_input_list.deserialize_aws_json_1_1(
+                data["commitIds"]
+            )
+        )
+    else:
+        raise DeserializationError("BatchGetCommitsInput.commit_ids required")
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("BatchGetCommitsInput.repository_name required")
+    return out

capo_codecommit/types/batch_get_commits_output.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetCommitsOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_get_commits_errors_list
+    import capo_codecommit.types.commit_objects_list
+
+
+class BatchGetCommitsOutput(TypedDict, closed=True):
+    commits: NotRequired["capo_codecommit.types.commit_objects_list.CommitObjectsList"]
+    """<p>An array of commit data type objects, each of which contains information about a specified commit.</p>"""
+    errors: NotRequired[
+        "capo_codecommit.types.batch_get_commits_errors_list.BatchGetCommitsErrorsList"
+    ]
+    """<p>Returns any commit IDs for which information could not be found. For example, if one of the commit IDs was a shortened SHA ID or that commit was not found in the specified repository, the ID returns an error object with more information.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetCommitsOutput) -> dict:
+    out: dict = {}
+    if "commits" in value:
+        import capo_codecommit.types.commit_objects_list
+
+        out["commits"] = (
+            capo_codecommit.types.commit_objects_list.serialize_aws_json_1_1(
+                value["commits"]
+            )
+        )
+    if "errors" in value:
+        import capo_codecommit.types.batch_get_commits_errors_list
+
+        out["errors"] = (
+            capo_codecommit.types.batch_get_commits_errors_list.serialize_aws_json_1_1(
+                value["errors"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetCommitsOutput:
+    out: BatchGetCommitsOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commits") is not None:
+        import capo_codecommit.types.commit_objects_list
+
+        out["commits"] = (
+            capo_codecommit.types.commit_objects_list.deserialize_aws_json_1_1(
+                data["commits"]
+            )
+        )
+    if data.get("errors") is not None:
+        import capo_codecommit.types.batch_get_commits_errors_list
+
+        out["errors"] = (
+            capo_codecommit.types.batch_get_commits_errors_list.deserialize_aws_json_1_1(
+                data["errors"]
+            )
+        )
+    return out

capo_codecommit/types/batch_get_repositories_error.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetRepositoriesError``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_get_repositories_error_code_enum
+    import capo_codecommit.types.error_message
+    import capo_codecommit.types.repository_id
+    import capo_codecommit.types.repository_name
+
+
+class BatchGetRepositoriesError(TypedDict, closed=True):
+    repository_id: NotRequired["capo_codecommit.types.repository_id.RepositoryId"]
+    """<p>The ID of a repository that either could not be found or was not in a valid state.</p>"""
+    repository_name: NotRequired["capo_codecommit.types.repository_name.RepositoryName"]
+    """<p>The name of a repository that either could not be found or was not in a valid state.</p>"""
+    error_code: NotRequired[
+        "capo_codecommit.types.batch_get_repositories_error_code_enum.BatchGetRepositoriesErrorCodeEnum"
+    ]
+    """<p>An error code that specifies the type of failure.</p>"""
+    error_message: NotRequired["capo_codecommit.types.error_message.ErrorMessage"]
+    """<p>An error message that provides detail about why the repository either was not found or was not in a valid state.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetRepositoriesError) -> dict:
+    out: dict = {}
+    if "repository_id" in value:
+        out["repositoryId"] = value["repository_id"]
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    if "error_code" in value:
+        import capo_codecommit.types.batch_get_repositories_error_code_enum
+
+        out["errorCode"] = (
+            capo_codecommit.types.batch_get_repositories_error_code_enum.serialize_aws_json_1_1(
+                value["error_code"]
+            )
+        )
+    if "error_message" in value:
+        out["errorMessage"] = value["error_message"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetRepositoriesError:
+    out: BatchGetRepositoriesError = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryId") is not None:
+        out["repository_id"] = data["repositoryId"]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    if data.get("errorCode") is not None:
+        import capo_codecommit.types.batch_get_repositories_error_code_enum
+
+        out["error_code"] = (
+            capo_codecommit.types.batch_get_repositories_error_code_enum.deserialize_aws_json_1_1(
+                data["errorCode"]
+            )
+        )
+    if data.get("errorMessage") is not None:
+        out["error_message"] = data["errorMessage"]
+    return out

capo_codecommit/types/batch_get_repositories_error_code_enum.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetRepositoriesErrorCodeEnum``."""
+
+from typing import Literal, TypeAlias, cast
+
+BatchGetRepositoriesErrorCodeEnum: TypeAlias = Literal[
+    "EncryptionIntegrityChecksFailedException",
+    "EncryptionKeyAccessDeniedException",
+    "EncryptionKeyDisabledException",
+    "EncryptionKeyNotFoundException",
+    "EncryptionKeyUnavailableException",
+    "RepositoryDoesNotExistException",
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetRepositoriesErrorCodeEnum) -> str:
+    return value
+
+
+def deserialize_aws_json_1_1(data: str) -> BatchGetRepositoriesErrorCodeEnum:
+    return cast(BatchGetRepositoriesErrorCodeEnum, data)

capo_codecommit/types/batch_get_repositories_errors_list.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetRepositoriesErrorsList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_get_repositories_error
+
+BatchGetRepositoriesErrorsList: TypeAlias = list[
+    "capo_codecommit.types.batch_get_repositories_error.BatchGetRepositoriesError"
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetRepositoriesErrorsList) -> list:
+    import capo_codecommit.types.batch_get_repositories_error
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codecommit.types.batch_get_repositories_error.serialize_aws_json_1_1(
+                item
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: list) -> BatchGetRepositoriesErrorsList:
+    import capo_codecommit.types.batch_get_repositories_error
+
+    out: BatchGetRepositoriesErrorsList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codecommit.types.batch_get_repositories_error.deserialize_aws_json_1_1(
+                item
+            )
+        )
+    return out

capo_codecommit/types/batch_get_repositories_input.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetRepositoriesInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.repository_name_list
+
+
+class BatchGetRepositoriesInput(TypedDict, closed=True):
+    repository_names: "capo_codecommit.types.repository_name_list.RepositoryNameList"
+    """<p>The names of the repositories to get information about.</p> <note> <p>The length constraint limit is for each string in the array. The array itself can be empty.</p> </note>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetRepositoriesInput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.repository_name_list
+
+    out["repositoryNames"] = (
+        capo_codecommit.types.repository_name_list.serialize_aws_json_1_1(
+            value["repository_names"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetRepositoriesInput:
+    out: BatchGetRepositoriesInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryNames") is not None:
+        import capo_codecommit.types.repository_name_list
+
+        out["repository_names"] = (
+            capo_codecommit.types.repository_name_list.deserialize_aws_json_1_1(
+                data["repositoryNames"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "BatchGetRepositoriesInput.repository_names required"
+        )
+    return out

capo_codecommit/types/batch_get_repositories_output.py

@@ -0,0 +1,84 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BatchGetRepositoriesOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.batch_get_repositories_errors_list
+    import capo_codecommit.types.repository_metadata_list
+    import capo_codecommit.types.repository_not_found_list
+
+
+class BatchGetRepositoriesOutput(TypedDict, closed=True):
+    repositories: NotRequired[
+        "capo_codecommit.types.repository_metadata_list.RepositoryMetadataList"
+    ]
+    """<p>A list of repositories returned by the batch get repositories operation.</p>"""
+    repositories_not_found: NotRequired[
+        "capo_codecommit.types.repository_not_found_list.RepositoryNotFoundList"
+    ]
+    """<p>Returns a list of repository names for which information could not be found.</p>"""
+    errors: NotRequired[
+        "capo_codecommit.types.batch_get_repositories_errors_list.BatchGetRepositoriesErrorsList"
+    ]
+    """<p>Returns information about any errors returned when attempting to retrieve information about the repositories.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BatchGetRepositoriesOutput) -> dict:
+    out: dict = {}
+    if "repositories" in value:
+        import capo_codecommit.types.repository_metadata_list
+
+        out["repositories"] = (
+            capo_codecommit.types.repository_metadata_list.serialize_aws_json_1_1(
+                value["repositories"]
+            )
+        )
+    if "repositories_not_found" in value:
+        import capo_codecommit.types.repository_not_found_list
+
+        out["repositoriesNotFound"] = (
+            capo_codecommit.types.repository_not_found_list.serialize_aws_json_1_1(
+                value["repositories_not_found"]
+            )
+        )
+    if "errors" in value:
+        import capo_codecommit.types.batch_get_repositories_errors_list
+
+        out["errors"] = (
+            capo_codecommit.types.batch_get_repositories_errors_list.serialize_aws_json_1_1(
+                value["errors"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BatchGetRepositoriesOutput:
+    out: BatchGetRepositoriesOutput = {}  # type: ignore[typeddict-item]
+    if data.get("repositories") is not None:
+        import capo_codecommit.types.repository_metadata_list
+
+        out["repositories"] = (
+            capo_codecommit.types.repository_metadata_list.deserialize_aws_json_1_1(
+                data["repositories"]
+            )
+        )
+    if data.get("repositoriesNotFound") is not None:
+        import capo_codecommit.types.repository_not_found_list
+
+        out["repositories_not_found"] = (
+            capo_codecommit.types.repository_not_found_list.deserialize_aws_json_1_1(
+                data["repositoriesNotFound"]
+            )
+        )
+    if data.get("errors") is not None:
+        import capo_codecommit.types.batch_get_repositories_errors_list
+
+        out["errors"] = (
+            capo_codecommit.types.batch_get_repositories_errors_list.deserialize_aws_json_1_1(
+                data["errors"]
+            )
+        )
+    return out

capo_codecommit/types/blob.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#blob``."""
+
+import base64
+from typing import TypeAlias
+
+blob: TypeAlias = bytes
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: blob) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_aws_json_1_1(data: str) -> blob:
+    return base64.b64decode(data)

capo_codecommit/types/blob_metadata.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BlobMetadata``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.mode
+    import capo_codecommit.types.object_id
+    import capo_codecommit.types.path
+
+
+class BlobMetadata(TypedDict, closed=True):
+    blob_id: NotRequired["capo_codecommit.types.object_id.ObjectId"]
+    """<p>The full ID of the blob.</p>"""
+    path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The path to the blob and associated file name, if any.</p>"""
+    mode: NotRequired["capo_codecommit.types.mode.Mode"]
+    """<p>The file mode permissions of the blob. File mode permission codes include:</p> <ul> <li> <p> <code>100644</code> indicates read/write</p> </li> <li> <p> <code>100755</code> indicates read/write/execute</p> </li> <li> <p> <code>160000</code> indicates a submodule</p> </li> <li> <p> <code>120000</code> indicates a symlink</p> </li> </ul>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BlobMetadata) -> dict:
+    out: dict = {}
+    if "blob_id" in value:
+        out["blobId"] = value["blob_id"]
+    if "path" in value:
+        out["path"] = value["path"]
+    if "mode" in value:
+        out["mode"] = value["mode"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BlobMetadata:
+    out: BlobMetadata = {}  # type: ignore[typeddict-item]
+    if data.get("blobId") is not None:
+        out["blob_id"] = data["blobId"]
+    if data.get("path") is not None:
+        out["path"] = data["path"]
+    if data.get("mode") is not None:
+        out["mode"] = data["mode"]
+    return out

capo_codecommit/types/branch_info.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BranchInfo``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.branch_name
+    import capo_codecommit.types.commit_id
+
+
+class BranchInfo(TypedDict, closed=True):
+    branch_name: NotRequired["capo_codecommit.types.branch_name.BranchName"]
+    """<p>The name of the branch.</p>"""
+    commit_id: NotRequired["capo_codecommit.types.commit_id.CommitId"]
+    """<p>The ID of the last commit made to the branch.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BranchInfo) -> dict:
+    out: dict = {}
+    if "branch_name" in value:
+        out["branchName"] = value["branch_name"]
+    if "commit_id" in value:
+        out["commitId"] = value["commit_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> BranchInfo:
+    out: BranchInfo = {}  # type: ignore[typeddict-item]
+    if data.get("branchName") is not None:
+        out["branch_name"] = data["branchName"]
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    return out

capo_codecommit/types/branch_name.py

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

capo_codecommit/types/branch_name_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#BranchNameList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.branch_name
+
+BranchNameList: TypeAlias = list["capo_codecommit.types.branch_name.BranchName"]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: BranchNameList) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_1(data: list) -> BranchNameList:
+    return [item for item in data if item is not None]

capo_codecommit/types/caller_reactions.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#CallerReactions``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.reaction_value
+
+CallerReactions: TypeAlias = list["capo_codecommit.types.reaction_value.ReactionValue"]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: CallerReactions) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_1(data: list) -> CallerReactions:
+    return [item for item in data if item is not None]

capo_codecommit/types/capital_boolean.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#CapitalBoolean``."""
+
+from typing import TypeAlias
+
+CapitalBoolean: TypeAlias = bool