capo-codecommit 0.1.0__py3-none-any.whl

capo_codecommit/types/folder.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#Folder``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.object_id
+    import capo_codecommit.types.path
+
+
+class Folder(TypedDict, closed=True):
+    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>"""
+    absolute_path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The fully qualified path of the folder in the repository.</p>"""
+    relative_path: NotRequired["capo_codecommit.types.path.Path"]
+    """<p>The relative path of the specified folder from the folder where the query originated.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: Folder) -> dict:
+    out: dict = {}
+    if "tree_id" in value:
+        out["treeId"] = value["tree_id"]
+    if "absolute_path" in value:
+        out["absolutePath"] = value["absolute_path"]
+    if "relative_path" in value:
+        out["relativePath"] = value["relative_path"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> Folder:
+    out: Folder = {}  # type: ignore[typeddict-item]
+    if data.get("treeId") is not None:
+        out["tree_id"] = data["treeId"]
+    if data.get("absolutePath") is not None:
+        out["absolute_path"] = data["absolutePath"]
+    if data.get("relativePath") is not None:
+        out["relative_path"] = data["relativePath"]
+    return out

capo_codecommit/types/folder_list.py

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

capo_codecommit/types/get_approval_rule_template_input.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetApprovalRuleTemplateInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.approval_rule_template_name
+
+
+class GetApprovalRuleTemplateInput(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 get information.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetApprovalRuleTemplateInput) -> dict:
+    out: dict = {}
+    out["approvalRuleTemplateName"] = value["approval_rule_template_name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetApprovalRuleTemplateInput:
+    out: GetApprovalRuleTemplateInput = {}  # type: ignore[typeddict-item]
+    if data.get("approvalRuleTemplateName") is not None:
+        out["approval_rule_template_name"] = data["approvalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "GetApprovalRuleTemplateInput.approval_rule_template_name required"
+        )
+    return out

capo_codecommit/types/get_approval_rule_template_output.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetApprovalRuleTemplateOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.approval_rule_template
+
+
+class GetApprovalRuleTemplateOutput(TypedDict, closed=True):
+    approval_rule_template: (
+        "capo_codecommit.types.approval_rule_template.ApprovalRuleTemplate"
+    )
+    """<p>The content and structure of the approval rule template.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetApprovalRuleTemplateOutput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.approval_rule_template
+
+    out["approvalRuleTemplate"] = (
+        capo_codecommit.types.approval_rule_template.serialize_aws_json_1_1(
+            value["approval_rule_template"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetApprovalRuleTemplateOutput:
+    out: GetApprovalRuleTemplateOutput = {}  # type: ignore[typeddict-item]
+    if data.get("approvalRuleTemplate") is not None:
+        import capo_codecommit.types.approval_rule_template
+
+        out["approval_rule_template"] = (
+            capo_codecommit.types.approval_rule_template.deserialize_aws_json_1_1(
+                data["approvalRuleTemplate"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetApprovalRuleTemplateOutput.approval_rule_template required"
+        )
+    return out

capo_codecommit/types/get_blob_input.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetBlobInput``."""
+
+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 GetBlobInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository that contains the blob.</p>"""
+    blob_id: "capo_codecommit.types.object_id.ObjectId"
+    """<p>The ID of the blob, which is its SHA-1 pointer.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetBlobInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    out["blobId"] = value["blob_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetBlobInput:
+    out: GetBlobInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("GetBlobInput.repository_name required")
+    if data.get("blobId") is not None:
+        out["blob_id"] = data["blobId"]
+    else:
+        raise DeserializationError("GetBlobInput.blob_id required")
+    return out

capo_codecommit/types/get_blob_output.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetBlobOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.blob
+
+
+class GetBlobOutput(TypedDict, closed=True):
+    content: "capo_codecommit.types.blob.blob"
+    """<p>The content of the blob, usually a file.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetBlobOutput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.blob
+
+    out["content"] = capo_codecommit.types.blob.serialize_aws_json_1_1(value["content"])
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetBlobOutput:
+    out: GetBlobOutput = {}  # type: ignore[typeddict-item]
+    if data.get("content") is not None:
+        import capo_codecommit.types.blob
+
+        out["content"] = capo_codecommit.types.blob.deserialize_aws_json_1_1(
+            data["content"]
+        )
+    else:
+        raise DeserializationError("GetBlobOutput.content required")
+    return out

capo_codecommit/types/get_branch_input.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetBranchInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.branch_name
+    import capo_codecommit.types.repository_name
+
+
+class GetBranchInput(TypedDict, closed=True):
+    repository_name: NotRequired["capo_codecommit.types.repository_name.RepositoryName"]
+    """<p>The name of the repository that contains the branch for which you want to retrieve information.</p>"""
+    branch_name: NotRequired["capo_codecommit.types.branch_name.BranchName"]
+    """<p>The name of the branch for which you want to retrieve information.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetBranchInput) -> dict:
+    out: dict = {}
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    if "branch_name" in value:
+        out["branchName"] = value["branch_name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetBranchInput:
+    out: GetBranchInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    if data.get("branchName") is not None:
+        out["branch_name"] = data["branchName"]
+    return out

capo_codecommit/types/get_branch_output.py

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

capo_codecommit/types/get_comment_input.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.comment_id
+
+
+class GetCommentInput(TypedDict, closed=True):
+    comment_id: "capo_codecommit.types.comment_id.CommentId"
+    """<p>The unique, system-generated ID of the comment. To get this ID, use <a>GetCommentsForComparedCommit</a> or <a>GetCommentsForPullRequest</a>.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentInput) -> dict:
+    out: dict = {}
+    out["commentId"] = value["comment_id"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommentInput:
+    out: GetCommentInput = {}  # type: ignore[typeddict-item]
+    if data.get("commentId") is not None:
+        out["comment_id"] = data["commentId"]
+    else:
+        raise DeserializationError("GetCommentInput.comment_id required")
+    return out

capo_codecommit/types/get_comment_output.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.comment
+
+
+class GetCommentOutput(TypedDict, closed=True):
+    comment: NotRequired["capo_codecommit.types.comment.Comment"]
+    """<p>The contents of the comment.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentOutput) -> dict:
+    out: dict = {}
+    if "comment" in value:
+        import capo_codecommit.types.comment
+
+        out["comment"] = capo_codecommit.types.comment.serialize_aws_json_1_1(
+            value["comment"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommentOutput:
+    out: GetCommentOutput = {}  # type: ignore[typeddict-item]
+    if data.get("comment") is not None:
+        import capo_codecommit.types.comment
+
+        out["comment"] = capo_codecommit.types.comment.deserialize_aws_json_1_1(
+            data["comment"]
+        )
+    return out

capo_codecommit/types/get_comment_reactions_input.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentReactionsInput``."""
+
+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.comment_id
+    import capo_codecommit.types.max_results
+    import capo_codecommit.types.next_token
+
+
+class GetCommentReactionsInput(TypedDict, closed=True):
+    comment_id: "capo_codecommit.types.comment_id.CommentId"
+    """<p>The ID of the comment for which you want to get reactions information.</p>"""
+    reaction_user_arn: NotRequired["capo_codecommit.types.arn.Arn"]
+    """<p>Optional. The Amazon Resource Name (ARN) of the user or identity for which you want to get reaction information.</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. The default is the same as the allowed maximum, 1,000.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentReactionsInput) -> dict:
+    out: dict = {}
+    out["commentId"] = value["comment_id"]
+    if "reaction_user_arn" in value:
+        out["reactionUserArn"] = value["reaction_user_arn"]
+    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) -> GetCommentReactionsInput:
+    out: GetCommentReactionsInput = {}  # type: ignore[typeddict-item]
+    if data.get("commentId") is not None:
+        out["comment_id"] = data["commentId"]
+    else:
+        raise DeserializationError("GetCommentReactionsInput.comment_id required")
+    if data.get("reactionUserArn") is not None:
+        out["reaction_user_arn"] = data["reactionUserArn"]
+    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/get_comment_reactions_output.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentReactionsOutput``."""
+
+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.reactions_for_comment_list
+
+
+class GetCommentReactionsOutput(TypedDict, closed=True):
+    reactions_for_comment: (
+        "capo_codecommit.types.reactions_for_comment_list.ReactionsForCommentList"
+    )
+    """<p>An array of reactions to the specified comment.</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: GetCommentReactionsOutput) -> dict:
+    out: dict = {}
+    import capo_codecommit.types.reactions_for_comment_list
+
+    out["reactionsForComment"] = (
+        capo_codecommit.types.reactions_for_comment_list.serialize_aws_json_1_1(
+            value["reactions_for_comment"]
+        )
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommentReactionsOutput:
+    out: GetCommentReactionsOutput = {}  # type: ignore[typeddict-item]
+    if data.get("reactionsForComment") is not None:
+        import capo_codecommit.types.reactions_for_comment_list
+
+        out["reactions_for_comment"] = (
+            capo_codecommit.types.reactions_for_comment_list.deserialize_aws_json_1_1(
+                data["reactionsForComment"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetCommentReactionsOutput.reactions_for_comment required"
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/get_comments_for_compared_commit_input.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentsForComparedCommitInput``."""
+
+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_id
+    import capo_codecommit.types.max_results
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.repository_name
+
+
+class GetCommentsForComparedCommitInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository where you want to compare commits.</p>"""
+    before_commit_id: NotRequired["capo_codecommit.types.commit_id.CommitId"]
+    """<p>To establish the directionality of the comparison, the full commit ID of the before commit.</p>"""
+    after_commit_id: "capo_codecommit.types.commit_id.CommitId"
+    """<p>To establish the directionality of the comparison, the full commit ID of the after commit.</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. The default is 100 comments, but you can configure up to 500.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentsForComparedCommitInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    if "before_commit_id" in value:
+        out["beforeCommitId"] = value["before_commit_id"]
+    out["afterCommitId"] = value["after_commit_id"]
+    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) -> GetCommentsForComparedCommitInput:
+    out: GetCommentsForComparedCommitInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError(
+            "GetCommentsForComparedCommitInput.repository_name required"
+        )
+    if data.get("beforeCommitId") is not None:
+        out["before_commit_id"] = data["beforeCommitId"]
+    if data.get("afterCommitId") is not None:
+        out["after_commit_id"] = data["afterCommitId"]
+    else:
+        raise DeserializationError(
+            "GetCommentsForComparedCommitInput.after_commit_id 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/get_comments_for_compared_commit_output.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentsForComparedCommitOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.comments_for_compared_commit_data
+    import capo_codecommit.types.next_token
+
+
+class GetCommentsForComparedCommitOutput(TypedDict, closed=True):
+    comments_for_compared_commit_data: NotRequired[
+        "capo_codecommit.types.comments_for_compared_commit_data.CommentsForComparedCommitData"
+    ]
+    """<p>A list of comment objects on the compared commit.</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: GetCommentsForComparedCommitOutput) -> dict:
+    out: dict = {}
+    if "comments_for_compared_commit_data" in value:
+        import capo_codecommit.types.comments_for_compared_commit_data
+
+        out["commentsForComparedCommitData"] = (
+            capo_codecommit.types.comments_for_compared_commit_data.serialize_aws_json_1_1(
+                value["comments_for_compared_commit_data"]
+            )
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> GetCommentsForComparedCommitOutput:
+    out: GetCommentsForComparedCommitOutput = {}  # type: ignore[typeddict-item]
+    if data.get("commentsForComparedCommitData") is not None:
+        import capo_codecommit.types.comments_for_compared_commit_data
+
+        out["comments_for_compared_commit_data"] = (
+            capo_codecommit.types.comments_for_compared_commit_data.deserialize_aws_json_1_1(
+                data["commentsForComparedCommitData"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_codecommit/types/get_comments_for_pull_request_input.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#GetCommentsForPullRequestInput``."""
+
+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_id
+    import capo_codecommit.types.max_results
+    import capo_codecommit.types.next_token
+    import capo_codecommit.types.pull_request_id
+    import capo_codecommit.types.repository_name
+
+
+class GetCommentsForPullRequestInput(TypedDict, closed=True):
+    pull_request_id: "capo_codecommit.types.pull_request_id.PullRequestId"
+    """<p>The system-generated ID of the pull request. To get this ID, use <a>ListPullRequests</a>.</p>"""
+    repository_name: NotRequired["capo_codecommit.types.repository_name.RepositoryName"]
+    """<p>The name of the repository that contains the pull request. Requirement is conditional: <code>repositoryName</code> must be specified when <code>beforeCommitId</code> and <code>afterCommitId</code> are included.</p>"""
+    before_commit_id: NotRequired["capo_codecommit.types.commit_id.CommitId"]
+    """<p>The full commit ID of the commit in the destination branch that was the tip of the branch at the time the pull request was created. Requirement is conditional: <code>beforeCommitId</code> must be specified when <code>repositoryName</code> is included.</p>"""
+    after_commit_id: NotRequired["capo_codecommit.types.commit_id.CommitId"]
+    """<p>The full commit ID of the commit in the source branch that was the tip of the branch at the time the comment was made. Requirement is conditional: <code>afterCommitId</code> must be specified when <code>repositoryName</code> is included.</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. The default is 100 comments. You can return up to 500 comments with a single request.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: GetCommentsForPullRequestInput) -> dict:
+    out: dict = {}
+    out["pullRequestId"] = value["pull_request_id"]
+    if "repository_name" in value:
+        out["repositoryName"] = value["repository_name"]
+    if "before_commit_id" in value:
+        out["beforeCommitId"] = value["before_commit_id"]
+    if "after_commit_id" in value:
+        out["afterCommitId"] = value["after_commit_id"]
+    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) -> GetCommentsForPullRequestInput:
+    out: GetCommentsForPullRequestInput = {}  # type: ignore[typeddict-item]
+    if data.get("pullRequestId") is not None:
+        out["pull_request_id"] = data["pullRequestId"]
+    else:
+        raise DeserializationError(
+            "GetCommentsForPullRequestInput.pull_request_id required"
+        )
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    if data.get("beforeCommitId") is not None:
+        out["before_commit_id"] = data["beforeCommitId"]
+    if data.get("afterCommitId") is not None:
+        out["after_commit_id"] = data["afterCommitId"]
+    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