capo-codecommit 0.1.0__py3-none-any.whl

capo_codecommit/types/get_comments_for_pull_request_output.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentsForPullRequestOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.comments_for_pull_request_data
+    import capo_codecommit.types.next_token
+
+
+class GetCommentsForPullRequestOutput(TypedDict, closed=True):
+    comments_for_pull_request_data: NotRequired[
+        "capo_codecommit.types.comments_for_pull_request_data.CommentsForPullRequestData"
+    ]
+    """<p>An array of comment objects on the pull request.</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that can be used in a request to return the next batch of the results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentsForPullRequestOutput) -> dict:
+    out: dict = {}
+    if "comments_for_pull_request_data" in value:
+        import capo_codecommit.types.comments_for_pull_request_data
+
+        out["commentsForPullRequestData"] = (
+            capo_codecommit.types.comments_for_pull_request_data.serialize_aws_json_1_1(
+                value["comments_for_pull_request_data"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommentsForPullRequestOutput:
+    out: GetCommentsForPullRequestOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commentsForPullRequestData") is not None:
+        import capo_codecommit.types.comments_for_pull_request_data
+
+        out["comments_for_pull_request_data"] = (
+            capo_codecommit.types.comments_for_pull_request_data.deserialize_aws_json_1_1(
+                data["commentsForPullRequestData"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/get_commit_input.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommitInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.object_id
+    import capo_codecommit.types.repository_name
+
+
+class GetCommitInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository to which the commit was made.</p>"""
+    commit_id: "capo_codecommit.types.object_id.ObjectId"
+    """<p>The commit ID. Commit IDs are the full SHA ID of the commit.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommitInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    out["commitId"] = value["commit_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommitInput:
+    out: GetCommitInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetCommitInput.repository_name required")
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    else:
+        raise DeserializationError("GetCommitInput.commit_id required")
+    return out

capo_codecommit/types/get_commit_output.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommitOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit
+
+
+class GetCommitOutput(TypedDict, closed=True):
+    commit: "capo_codecommit.types.commit.Commit"
+    """<p>A commit data type object that contains information about the specified commit.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommitOutput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.commit
+
+    out["commit"] = capo_codecommit.types.commit.serialize_aws_json_1_1(value["commit"])
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommitOutput:
+    out: GetCommitOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commit") is not None:
+        import capo_codecommit.types.commit
+
+        out["commit"] = capo_codecommit.types.commit.deserialize_aws_json_1_1(
+            data["commit"]
+        )
+    else:
+        raise DeserializationError("GetCommitOutput.commit required")
+    return out

capo_codecommit/types/get_differences_input.py

@@ -0,0 +1,74 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetDifferencesInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit_name
+    import capo_codecommit.types.limit
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.path
+    import capo_codecommit.types.repository_name
+
+
+class GetDifferencesInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository where you want to get differences.</p>"""
+    before_commit_specifier: NotRequired["capo_codecommit.types.commit_name.CommitName"]
+    """<p>The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, the full commit ID). Optional. If not specified, all changes before the <code>afterCommitSpecifier</code> value are shown. If you do not use <code>beforeCommitSpecifier</code> in your request, consider limiting the results with <code>maxResults</code>.</p>"""
+    after_commit_specifier: "capo_codecommit.types.commit_name.CommitName"
+    """<p>The branch, tag, HEAD, or other fully qualified reference used to identify a commit.</p>"""
+    before_path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The file path in which to check for differences. Limits the results to this path. Can also be used to specify the previous name of a directory or folder. If <code>beforePath</code> and <code>afterPath</code> are not specified, differences are shown for all paths.</p>"""
+    after_path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The file path in which to check differences. Limits the results to this path. Can also be used to specify the changed name of a directory or folder, if it has changed. If not specified, differences are shown for all paths.</p>"""
+    max_results: NotRequired["capo_codecommit.types.limit.Limit"]
+    """<p>A non-zero, non-negative integer used to limit the number of returned results.</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: GetDifferencesInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    if "before_commit_specifier" in value:
+        out["beforeCommitSpecifier"] = value["before_commit_specifier"]
+    out["afterCommitSpecifier"] = value["after_commit_specifier"]
+    if "before_path" in value:
+        out["beforePath"] = value["before_path"]
+    if "after_path" in value:
+        out["afterPath"] = value["after_path"]
+    if "max_results" in value:
+        out["MaxResults"] = value["max_results"]
+    if "next_token" in value:
+        out["NextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetDifferencesInput:
+    out: GetDifferencesInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetDifferencesInput.repository_name required")
+    if data.get("beforeCommitSpecifier") is not None:
+        out["before_commit_specifier"] = data["beforeCommitSpecifier"]
+    if data.get("afterCommitSpecifier") is not None:
+        out["after_commit_specifier"] = data["afterCommitSpecifier"]
+    else:
+        raise DeserializationError(
+            "GetDifferencesInput.after_commit_specifier required"
+        )
+    if data.get("beforePath") is not None:
+        out["before_path"] = data["beforePath"]
+    if data.get("afterPath") is not None:
+        out["after_path"] = data["afterPath"]
+    if data.get("MaxResults") is not None:
+        out["max_results"] = data["MaxResults"]
+    if data.get("NextToken") is not None:
+        out["next_token"] = data["NextToken"]
+    return out

capo_codecommit/types/get_differences_output.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetDifferencesOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.difference_list
+    import capo_codecommit.types.next_token
+
+
+class GetDifferencesOutput(TypedDict, closed=True):
+    differences: NotRequired["capo_codecommit.types.difference_list.DifferenceList"]
+    """<p>A data type object that contains information about the differences, including whether the difference is added, modified, or deleted (A, D, M).</p>"""
+    next_token: NotRequired["capo_codecommit.types.next_token.NextToken"]
+    """<p>An enumeration token that can be used in a request to return the next batch of the results.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetDifferencesOutput) -> dict:
+    out: dict = {}
+    if "differences" in value:
+        import capo_codecommit.types.difference_list
+
+        out["differences"] = (
+            capo_codecommit.types.difference_list.serialize_aws_json_1_1(
+                value["differences"]
+            )
+        )
+    if "next_token" in value:
+        out["NextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetDifferencesOutput:
+    out: GetDifferencesOutput = {}  # type: ignore[typeddict-item]
+    if data.get("differences") is not None:
+        import capo_codecommit.types.difference_list
+
+        out["differences"] = (
+            capo_codecommit.types.difference_list.deserialize_aws_json_1_1(
+                data["differences"]
+            )
+        )
+    if data.get("NextToken") is not None:
+        out["next_token"] = data["NextToken"]
+    return out

capo_codecommit/types/get_file_input.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetFileInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit_name
+    import capo_codecommit.types.path
+    import capo_codecommit.types.repository_name
+
+
+class GetFileInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository that contains the file.</p>"""
+    commit_specifier: NotRequired["capo_codecommit.types.commit_name.CommitName"]
+    """<p>The fully quaified reference that identifies the commit that contains the file. For example, you can specify a full commit ID, a tag, a branch name, or a reference such as refs/heads/main. If none is provided, the head commit is used.</p>"""
+    file_path: "capo_codecommit.types.path.Path"
+    """<p>The fully qualified path to the file, including the full name and extension of the file. For example, /examples/file.md is the fully qualified path to a file named file.md in a folder named examples.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetFileInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    if "commit_specifier" in value:
+        out["commitSpecifier"] = value["commit_specifier"]
+    out["filePath"] = value["file_path"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetFileInput:
+    out: GetFileInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetFileInput.repository_name required")
+    if data.get("commitSpecifier") is not None:
+        out["commit_specifier"] = data["commitSpecifier"]
+    if data.get("filePath") is not None:
+        out["file_path"] = data["filePath"]
+    else:
+        raise DeserializationError("GetFileInput.file_path required")
+    return out

capo_codecommit/types/get_file_output.py

@@ -0,0 +1,90 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetFileOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.file_content
+    import capo_codecommit.types.file_mode_type_enum
+    import capo_codecommit.types.object_id
+    import capo_codecommit.types.object_size
+    import capo_codecommit.types.path
+
+
+class GetFileOutput(TypedDict, closed=True):
+    commit_id: "capo_codecommit.types.object_id.ObjectId"
+    """<p>The full commit ID of the commit that contains the content returned by GetFile.</p>"""
+    blob_id: "capo_codecommit.types.object_id.ObjectId"
+    """<p>The blob ID of the object that represents the file content.</p>"""
+    file_path: "capo_codecommit.types.path.Path"
+    """<p>The fully qualified path to the specified file. Returns the name and extension of the file.</p>"""
+    file_mode: "capo_codecommit.types.file_mode_type_enum.FileModeTypeEnum"
+    """<p>The extrapolated file mode permissions of the blob. Valid values include strings such as EXECUTABLE and not numeric values.</p> <note> <p>The file mode permissions returned by this API are not the standard file mode permission values, such as 100644, but rather extrapolated values. See the supported return values.</p> </note>"""
+    file_size: "capo_codecommit.types.object_size.ObjectSize"
+    """<p>The size of the contents of the file, in bytes.</p>"""
+    file_content: "capo_codecommit.types.file_content.FileContent"
+    """<p>The base-64 encoded binary data object that represents the content of the file.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetFileOutput) -> dict:
+    out: dict = {}
+    out["commitId"] = value["commit_id"]
+    out["blobId"] = value["blob_id"]
+    out["filePath"] = value["file_path"]
+    import capo_codecommit.types.file_mode_type_enum
+
+    out["fileMode"] = capo_codecommit.types.file_mode_type_enum.serialize_aws_json_1_1(
+        value["file_mode"]
+    )
+    out["fileSize"] = value.get("file_size", 0)
+    import capo_codecommit.types.file_content
+
+    out["fileContent"] = capo_codecommit.types.file_content.serialize_aws_json_1_1(
+        value["file_content"]
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetFileOutput:
+    out: GetFileOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    else:
+        raise DeserializationError("GetFileOutput.commit_id required")
+    if data.get("blobId") is not None:
+        out["blob_id"] = data["blobId"]
+    else:
+        raise DeserializationError("GetFileOutput.blob_id required")
+    if data.get("filePath") is not None:
+        out["file_path"] = data["filePath"]
+    else:
+        raise DeserializationError("GetFileOutput.file_path required")
+    if data.get("fileMode") is not None:
+        import capo_codecommit.types.file_mode_type_enum
+
+        out["file_mode"] = (
+            capo_codecommit.types.file_mode_type_enum.deserialize_aws_json_1_1(
+                data["fileMode"]
+            )
+        )
+    else:
+        raise DeserializationError("GetFileOutput.file_mode required")
+    if data.get("fileSize") is not None:
+        out["file_size"] = data["fileSize"]
+    else:
+        out["file_size"] = 0
+    if data.get("fileContent") is not None:
+        import capo_codecommit.types.file_content
+
+        out["file_content"] = (
+            capo_codecommit.types.file_content.deserialize_aws_json_1_1(
+                data["fileContent"]
+            )
+        )
+    else:
+        raise DeserializationError("GetFileOutput.file_content required")
+    return out

capo_codecommit/types/get_folder_input.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetFolderInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit_name
+    import capo_codecommit.types.path
+    import capo_codecommit.types.repository_name
+
+
+class GetFolderInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository.</p>"""
+    commit_specifier: NotRequired["capo_codecommit.types.commit_name.CommitName"]
+    """<p>A fully qualified reference used to identify a commit that contains the version of the folder's content to return. A fully qualified reference can be a commit ID, branch name, tag, or reference such as HEAD. If no specifier is provided, the folder content is returned as it exists in the HEAD commit.</p>"""
+    folder_path: "capo_codecommit.types.path.Path"
+    """<p>The fully qualified path to the folder whose contents are returned, including the folder name. For example, /examples is a fully-qualified path to a folder named examples that was created off of the root directory (/) of a repository. </p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetFolderInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    if "commit_specifier" in value:
+        out["commitSpecifier"] = value["commit_specifier"]
+    out["folderPath"] = value["folder_path"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetFolderInput:
+    out: GetFolderInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetFolderInput.repository_name required")
+    if data.get("commitSpecifier") is not None:
+        out["commit_specifier"] = data["commitSpecifier"]
+    if data.get("folderPath") is not None:
+        out["folder_path"] = data["folderPath"]
+    else:
+        raise DeserializationError("GetFolderInput.folder_path required")
+    return out

capo_codecommit/types/get_folder_output.py

@@ -0,0 +1,115 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetFolderOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.file_list
+    import capo_codecommit.types.folder_list
+    import capo_codecommit.types.object_id
+    import capo_codecommit.types.path
+    import capo_codecommit.types.sub_module_list
+    import capo_codecommit.types.symbolic_link_list
+
+
+class GetFolderOutput(TypedDict, closed=True):
+    commit_id: "capo_codecommit.types.object_id.ObjectId"
+    """<p>The full commit ID used as a reference for the returned version of the folder content.</p>"""
+    folder_path: "capo_codecommit.types.path.Path"
+    """<p>The fully qualified path of the folder whose contents are returned.</p>"""
+    tree_id: NotRequired["capo_codecommit.types.object_id.ObjectId"]
+    """<p>The full SHA-1 pointer of the tree information for the commit that contains the folder.</p>"""
+    sub_folders: NotRequired["capo_codecommit.types.folder_list.FolderList"]
+    """<p>The list of folders that exist under the specified folder, if any.</p>"""
+    files: NotRequired["capo_codecommit.types.file_list.FileList"]
+    """<p>The list of files in the specified folder, if any.</p>"""
+    symbolic_links: NotRequired[
+        "capo_codecommit.types.symbolic_link_list.SymbolicLinkList"
+    ]
+    """<p>The list of symbolic links to other files and folders in the specified folder, if any.</p>"""
+    sub_modules: NotRequired["capo_codecommit.types.sub_module_list.SubModuleList"]
+    """<p>The list of submodules in the specified folder, if any.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetFolderOutput) -> dict:
+    out: dict = {}
+    out["commitId"] = value["commit_id"]
+    out["folderPath"] = value["folder_path"]
+    if "tree_id" in value:
+        out["treeId"] = value["tree_id"]
+    if "sub_folders" in value:
+        import capo_codecommit.types.folder_list
+
+        out["subFolders"] = capo_codecommit.types.folder_list.serialize_aws_json_1_1(
+            value["sub_folders"]
+        )
+    if "files" in value:
+        import capo_codecommit.types.file_list
+
+        out["files"] = capo_codecommit.types.file_list.serialize_aws_json_1_1(
+            value["files"]
+        )
+    if "symbolic_links" in value:
+        import capo_codecommit.types.symbolic_link_list
+
+        out["symbolicLinks"] = (
+            capo_codecommit.types.symbolic_link_list.serialize_aws_json_1_1(
+                value["symbolic_links"]
+            )
+        )
+    if "sub_modules" in value:
+        import capo_codecommit.types.sub_module_list
+
+        out["subModules"] = (
+            capo_codecommit.types.sub_module_list.serialize_aws_json_1_1(
+                value["sub_modules"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetFolderOutput:
+    out: GetFolderOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commitId") is not None:
+        out["commit_id"] = data["commitId"]
+    else:
+        raise DeserializationError("GetFolderOutput.commit_id required")
+    if data.get("folderPath") is not None:
+        out["folder_path"] = data["folderPath"]
+    else:
+        raise DeserializationError("GetFolderOutput.folder_path required")
+    if data.get("treeId") is not None:
+        out["tree_id"] = data["treeId"]
+    if data.get("subFolders") is not None:
+        import capo_codecommit.types.folder_list
+
+        out["sub_folders"] = capo_codecommit.types.folder_list.deserialize_aws_json_1_1(
+            data["subFolders"]
+        )
+    if data.get("files") is not None:
+        import capo_codecommit.types.file_list
+
+        out["files"] = capo_codecommit.types.file_list.deserialize_aws_json_1_1(
+            data["files"]
+        )
+    if data.get("symbolicLinks") is not None:
+        import capo_codecommit.types.symbolic_link_list
+
+        out["symbolic_links"] = (
+            capo_codecommit.types.symbolic_link_list.deserialize_aws_json_1_1(
+                data["symbolicLinks"]
+            )
+        )
+    if data.get("subModules") is not None:
+        import capo_codecommit.types.sub_module_list
+
+        out["sub_modules"] = (
+            capo_codecommit.types.sub_module_list.deserialize_aws_json_1_1(
+                data["subModules"]
+            )
+        )
+    return out

capo_codecommit/types/get_merge_commit_input.py

@@ -0,0 +1,92 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetMergeCommitInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.commit_name
+    import capo_codecommit.types.conflict_detail_level_type_enum
+    import capo_codecommit.types.conflict_resolution_strategy_type_enum
+    import capo_codecommit.types.repository_name
+
+
+class GetMergeCommitInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository that contains the merge commit about which you want to get information.</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>"""
+    conflict_detail_level: NotRequired[
+        "capo_codecommit.types.conflict_detail_level_type_enum.ConflictDetailLevelTypeEnum"
+    ]
+    """<p>The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.</p>"""
+    conflict_resolution_strategy: NotRequired[
+        "capo_codecommit.types.conflict_resolution_strategy_type_enum.ConflictResolutionStrategyTypeEnum"
+    ]
+    """<p>Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetMergeCommitInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    out["sourceCommitSpecifier"] = value["source_commit_specifier"]
+    out["destinationCommitSpecifier"] = value["destination_commit_specifier"]
+    if "conflict_detail_level" in value:
+        import capo_codecommit.types.conflict_detail_level_type_enum
+
+        out["conflictDetailLevel"] = (
+            capo_codecommit.types.conflict_detail_level_type_enum.serialize_aws_json_1_1(
+                value["conflict_detail_level"]
+            )
+        )
+    if "conflict_resolution_strategy" in value:
+        import capo_codecommit.types.conflict_resolution_strategy_type_enum
+
+        out["conflictResolutionStrategy"] = (
+            capo_codecommit.types.conflict_resolution_strategy_type_enum.serialize_aws_json_1_1(
+                value["conflict_resolution_strategy"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetMergeCommitInput:
+    out: GetMergeCommitInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetMergeCommitInput.repository_name required")
+    if data.get("sourceCommitSpecifier") is not None:
+        out["source_commit_specifier"] = data["sourceCommitSpecifier"]
+    else:
+        raise DeserializationError(
+            "GetMergeCommitInput.source_commit_specifier required"
+        )
+    if data.get("destinationCommitSpecifier") is not None:
+        out["destination_commit_specifier"] = data["destinationCommitSpecifier"]
+    else:
+        raise DeserializationError(
+            "GetMergeCommitInput.destination_commit_specifier required"
+        )
+    if data.get("conflictDetailLevel") is not None:
+        import capo_codecommit.types.conflict_detail_level_type_enum
+
+        out["conflict_detail_level"] = (
+            capo_codecommit.types.conflict_detail_level_type_enum.deserialize_aws_json_1_1(
+                data["conflictDetailLevel"]
+            )
+        )
+    if data.get("conflictResolutionStrategy") is not None:
+        import capo_codecommit.types.conflict_resolution_strategy_type_enum
+
+        out["conflict_resolution_strategy"] = (
+            capo_codecommit.types.conflict_resolution_strategy_type_enum.deserialize_aws_json_1_1(
+                data["conflictResolutionStrategy"]
+            )
+        )
+    return out