capo-codecommit 0.1.0__py3-none-any.whl

capo_codecommit/types/list_file_commit_history_response.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListFileCommitHistoryResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.revision_dag
+
+
+class ListFileCommitHistoryResponse(TypedDict, closed=True):
+    revision_dag: "capo_codecommit.types.revision_dag.RevisionDag"
+    """<p>An array of FileVersion objects that form a directed acyclic graph (DAG) of the changes to the file made by the commits that changed the file.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that can be used to return the next batch of results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListFileCommitHistoryResponse) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.revision_dag
+
+    out["revisionDag"] = capo_codecommit.types.revision_dag.serialize_aws_json_1_1(
+        value["revision_dag"]
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListFileCommitHistoryResponse:
+    out: ListFileCommitHistoryResponse = {}  # type: ignore[typeddict-item]
+    if data.get("revisionDag") is not None:
+        import capo_codecommit.types.revision_dag
+
+        out["revision_dag"] = (
+            capo_codecommit.types.revision_dag.deserialize_aws_json_1_1(
+                data["revisionDag"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListFileCommitHistoryResponse.revision_dag required"
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/list_pull_requests_input.py

@@ -0,0 +1,73 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListPullRequestsInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.arn
+    import capo_codecommit.types.max_results
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.pull_request_status_enum
+    import capo_codecommit.types.repository_name
+
+
+class ListPullRequestsInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository for which you want to list pull requests.</p>"""
+    author_arn: NotRequired["capo_codecommit.types.arn.Arn"]
+    """<p>Optional. The Amazon Resource Name (ARN) of the user who created the pull request. If used, this filters the results to pull requests created by that user.</p>"""
+    pull_request_status: NotRequired[
+        "capo_codecommit.types.pull_request_status_enum.PullRequestStatusEnum"
+    ]
+    """<p>Optional. The status of the pull request. If used, this refines the results to the pull requests that match the specified status.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that, when provided in a request, returns the next batch of the results.</p>"""
+    max_results: NotRequired["capo_codecommit.types.max_results.MaxResults"]
+    """<p>A non-zero, non-negative integer used to limit the number of returned results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListPullRequestsInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    if "author_arn" in value:
+        out["authorArn"] = value["author_arn"]
+    if "pull_request_status" in value:
+        import capo_codecommit.types.pull_request_status_enum
+
+        out["pullRequestStatus"] = (
+            capo_codecommit.types.pull_request_status_enum.serialize_aws_json_1_1(
+                value["pull_request_status"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListPullRequestsInput:
+    out: ListPullRequestsInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("ListPullRequestsInput.repository_name required")
+    if data.get("authorArn") is not None:
+        out["author_arn"] = data["authorArn"]
+    if data.get("pullRequestStatus") is not None:
+        import capo_codecommit.types.pull_request_status_enum
+
+        out["pull_request_status"] = (
+            capo_codecommit.types.pull_request_status_enum.deserialize_aws_json_1_1(
+                data["pullRequestStatus"]
+            )
+        )
+    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_codecommit/types/list_pull_requests_output.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListPullRequestsOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.pull_request_id_list
+
+
+class ListPullRequestsOutput(TypedDict, closed=True):
+    pull_request_ids: "capo_codecommit.types.pull_request_id_list.PullRequestIdList"
+    """<p>The system-generated IDs of the pull requests.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that allows the operation to batch the next results of the operation.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListPullRequestsOutput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.pull_request_id_list
+
+    out["pullRequestIds"] = (
+        capo_codecommit.types.pull_request_id_list.serialize_aws_json_1_1(
+            value["pull_request_ids"]
+        )
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListPullRequestsOutput:
+    out: ListPullRequestsOutput = {}  # type: ignore[typeddict-item]
+    if data.get("pullRequestIds") is not None:
+        import capo_codecommit.types.pull_request_id_list
+
+        out["pull_request_ids"] = (
+            capo_codecommit.types.pull_request_id_list.deserialize_aws_json_1_1(
+                data["pullRequestIds"]
+            )
+        )
+    else:
+        raise DeserializationError("ListPullRequestsOutput.pull_request_ids required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/list_repositories_for_approval_rule_template_input.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListRepositoriesForApprovalRuleTemplateInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.approval_rule_template_name
+    import capo_codecommit.types.max_results
+    import capo_codecommit.types.next_token
+
+
+class ListRepositoriesForApprovalRuleTemplateInput(TypedDict, closed=True):
+    approval_rule_template_name: (
+        "capo_codecommit.types.approval_rule_template_name.ApprovalRuleTemplateName"
+    )
+    """<p>The name of the approval rule template for which you want to list repositories that are associated with that template.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that, when provided in a request, returns the next batch of the results.</p>"""
+    max_results: NotRequired["capo_codecommit.types.max_results.MaxResults"]
+    """<p>A non-zero, non-negative integer used to limit the number of returned results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListRepositoriesForApprovalRuleTemplateInput) -> dict:
+    out: dict = {}
+    out["approvalRuleTemplateName"] = value["approval_rule_template_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_aws_json_1_1(
+    data: dict,
+) -> ListRepositoriesForApprovalRuleTemplateInput:
+    out: ListRepositoriesForApprovalRuleTemplateInput = {}  # type: ignore[typeddict-item]
+    if data.get("approvalRuleTemplateName") is not None:
+        out["approval_rule_template_name"] = data["approvalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "ListRepositoriesForApprovalRuleTemplateInput.approval_rule_template_name required"
+        )
+    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_codecommit/types/list_repositories_for_approval_rule_template_output.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListRepositoriesForApprovalRuleTemplateOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.repository_name_list
+
+
+class ListRepositoriesForApprovalRuleTemplateOutput(TypedDict, closed=True):
+    repository_names: NotRequired[
+        "capo_codecommit.types.repository_name_list.RepositoryNameList"
+    ]
+    """<p>A list of repository names that are associated with the specified approval rule template.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that allows the operation to batch the next results of the operation.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(
+    value: ListRepositoriesForApprovalRuleTemplateOutput,
+) -> dict:
+    out: dict = {}
+    if "repository_names" in value:
+        import capo_codecommit.types.repository_name_list
+
+        out["repositoryNames"] = (
+            capo_codecommit.types.repository_name_list.serialize_aws_json_1_1(
+                value["repository_names"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(
+    data: dict,
+) -> ListRepositoriesForApprovalRuleTemplateOutput:
+    out: ListRepositoriesForApprovalRuleTemplateOutput = {}  # 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"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/list_repositories_input.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListRepositoriesInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.order_enum
+    import capo_codecommit.types.sort_by_enum
+
+
+class ListRepositoriesInput(TypedDict, closed=True):
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that allows the operation to batch the results of the operation. Batch sizes are 1,000 for list repository operations. When the client sends the token back to CodeCommit, another page of 1,000 records is retrieved.</p>"""
+    sort_by: NotRequired["capo_codecommit.types.sort_by_enum.SortByEnum"]
+    """<p>The criteria used to sort the results of a list repositories operation.</p>"""
+    order: NotRequired["capo_codecommit.types.order_enum.OrderEnum"]
+    """<p>The order in which to sort the results of a list repositories operation.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListRepositoriesInput) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "sort_by" in value:
+        import capo_codecommit.types.sort_by_enum
+
+        out["sortBy"] = capo_codecommit.types.sort_by_enum.serialize_aws_json_1_1(
+            value["sort_by"]
+        )
+    if "order" in value:
+        import capo_codecommit.types.order_enum
+
+        out["order"] = capo_codecommit.types.order_enum.serialize_aws_json_1_1(
+            value["order"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListRepositoriesInput:
+    out: ListRepositoriesInput = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("sortBy") is not None:
+        import capo_codecommit.types.sort_by_enum
+
+        out["sort_by"] = capo_codecommit.types.sort_by_enum.deserialize_aws_json_1_1(
+            data["sortBy"]
+        )
+    if data.get("order") is not None:
+        import capo_codecommit.types.order_enum
+
+        out["order"] = capo_codecommit.types.order_enum.deserialize_aws_json_1_1(
+            data["order"]
+        )
+    return out

capo_codecommit/types/list_repositories_output.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListRepositoriesOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.repository_name_id_pair_list
+
+
+class ListRepositoriesOutput(TypedDict, closed=True):
+    repositories: NotRequired[
+        "capo_codecommit.types.repository_name_id_pair_list.RepositoryNameIdPairList"
+    ]
+    """<p>Lists the repositories called by the list repositories operation.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that allows the operation to batch the results of the operation. Batch sizes are 1,000 for list repository operations. When the client sends the token back to CodeCommit, another page of 1,000 records is retrieved.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListRepositoriesOutput) -> dict:
+    out: dict = {}
+    if "repositories" in value:
+        import capo_codecommit.types.repository_name_id_pair_list
+
+        out["repositories"] = (
+            capo_codecommit.types.repository_name_id_pair_list.serialize_aws_json_1_1(
+                value["repositories"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListRepositoriesOutput:
+    out: ListRepositoriesOutput = {}  # type: ignore[typeddict-item]
+    if data.get("repositories") is not None:
+        import capo_codecommit.types.repository_name_id_pair_list
+
+        out["repositories"] = (
+            capo_codecommit.types.repository_name_id_pair_list.deserialize_aws_json_1_1(
+                data["repositories"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/list_tags_for_resource_input.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListTagsForResourceInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.resource_arn
+
+
+class ListTagsForResourceInput(TypedDict, closed=True):
+    resource_arn: "capo_codecommit.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the resource for which you want to get information about tags, if any.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that, when provided in a request, returns the next batch of the results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListTagsForResourceInput) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListTagsForResourceInput:
+    out: ListTagsForResourceInput = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("ListTagsForResourceInput.resource_arn required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/list_tags_for_resource_output.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#ListTagsForResourceOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.tags_map
+
+
+class ListTagsForResourceOutput(TypedDict, closed=True):
+    tags: NotRequired["capo_codecommit.types.tags_map.TagsMap"]
+    """<p>A list of tag key and value pairs associated with the specified resource.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that allows the operation to batch the next results of the operation.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ListTagsForResourceOutput) -> dict:
+    out: dict = {}
+    if "tags" in value:
+        import capo_codecommit.types.tags_map
+
+        out["tags"] = capo_codecommit.types.tags_map.serialize_aws_json_1_1(
+            value["tags"]
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ListTagsForResourceOutput:
+    out: ListTagsForResourceOutput = {}  # type: ignore[typeddict-item]
+    if data.get("tags") is not None:
+        import capo_codecommit.types.tags_map
+
+        out["tags"] = capo_codecommit.types.tags_map.deserialize_aws_json_1_1(
+            data["tags"]
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/location.py

@@ -0,0 +1,56 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#Location``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.path
+    import capo_codecommit.types.position
+    import capo_codecommit.types.relative_file_version_enum
+
+
+class Location(TypedDict, closed=True):
+    file_path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The name of the file being compared, including its extension and subdirectory, if any.</p>"""
+    file_position: NotRequired["capo_codecommit.types.position.Position"]
+    """<p>The position of a change in a compared file, in line number format.</p>"""
+    relative_file_version: NotRequired[
+        "capo_codecommit.types.relative_file_version_enum.RelativeFileVersionEnum"
+    ]
+    """<p>In a comparison of commits or a pull request, whether the change is in the before or after of that comparison.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: Location) -> dict:
+    out: dict = {}
+    if "file_path" in value:
+        out["filePath"] = value["file_path"]
+    if "file_position" in value:
+        out["filePosition"] = value["file_position"]
+    if "relative_file_version" in value:
+        import capo_codecommit.types.relative_file_version_enum
+
+        out["relativeFileVersion"] = (
+            capo_codecommit.types.relative_file_version_enum.serialize_aws_json_1_1(
+                value["relative_file_version"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> Location:
+    out: Location = {}  # type: ignore[typeddict-item]
+    if data.get("filePath") is not None:
+        out["file_path"] = data["filePath"]
+    if data.get("filePosition") is not None:
+        out["file_position"] = data["filePosition"]
+    if data.get("relativeFileVersion") is not None:
+        import capo_codecommit.types.relative_file_version_enum
+
+        out["relative_file_version"] = (
+            capo_codecommit.types.relative_file_version_enum.deserialize_aws_json_1_1(
+                data["relativeFileVersion"]
+            )
+        )
+    return out

capo_codecommit/types/max_results.py

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

capo_codecommit/types/merge_branches_by_fast_forward_input.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#MergeBranchesByFastForwardInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.branch_name
+    import capo_codecommit.types.commit_name
+    import capo_codecommit.types.repository_name
+
+
+class MergeBranchesByFastForwardInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository where you want to merge two branches.</p>"""
+    source_commit_specifier: "capo_codecommit.types.commit_name.CommitName"
+    """<p>The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).</p>"""
+    destination_commit_specifier: "capo_codecommit.types.commit_name.CommitName"
+    """<p>The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).</p>"""
+    target_branch: NotRequired["capo_codecommit.types.branch_name.BranchName"]
+    """<p>The branch where the merge is applied.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: MergeBranchesByFastForwardInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    out["sourceCommitSpecifier"] = value["source_commit_specifier"]
+    out["destinationCommitSpecifier"] = value["destination_commit_specifier"]
+    if "target_branch" in value:
+        out["targetBranch"] = value["target_branch"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> MergeBranchesByFastForwardInput:
+    out: MergeBranchesByFastForwardInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError(
+            "MergeBranchesByFastForwardInput.repository_name required"
+        )
+    if data.get("sourceCommitSpecifier") is not None:
+        out["source_commit_specifier"] = data["sourceCommitSpecifier"]
+    else:
+        raise DeserializationError(
+            "MergeBranchesByFastForwardInput.source_commit_specifier required"
+        )
+    if data.get("destinationCommitSpecifier") is not None:
+        out["destination_commit_specifier"] = data["destinationCommitSpecifier"]
+    else:
+        raise DeserializationError(
+            "MergeBranchesByFastForwardInput.destination_commit_specifier required"
+        )
+    if data.get("targetBranch") is not None:
+        out["target_branch"] = data["targetBranch"]
+    return out

capo_codecommit/types/merge_branches_by_fast_forward_output.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#MergeBranchesByFastForwardOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.object_id
+
+
+class MergeBranchesByFastForwardOutput(TypedDict, closed=True):
+    commit_id: NotRequired["capo_codecommit.types.object_id.ObjectId"]
+    """<p>The commit ID of the merge in the destination or target branch.</p>"""
+    tree_id: NotRequired["capo_codecommit.types.object_id.ObjectId"]
+    """<p>The tree ID of the merge in the destination or target branch.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: MergeBranchesByFastForwardOutput) -> dict:
+    out: dict = {}
+    if "commit_id" in value:
+        out["commitId"] = value["commit_id"]
+    if "tree_id" in value:
+        out["treeId"] = value["tree_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> MergeBranchesByFastForwardOutput:
+    out: MergeBranchesByFastForwardOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    if data.get("treeId") is not None:
+        out["tree_id"] = data["treeId"]
+    return out