capo-codecommit 0.1.0__py3-none-any.whl

capo_codecommit/types/symbolic_link_list.py

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

capo_codecommit/types/tag_key.py

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

capo_codecommit/types/tag_keys_list.py

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

capo_codecommit/types/tag_resource_input.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#TagResourceInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.resource_arn
+    import capo_codecommit.types.tags_map
+
+
+class TagResourceInput(TypedDict, closed=True):
+    resource_arn: "capo_codecommit.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the resource to which you want to add or update tags.</p>"""
+    tags: "capo_codecommit.types.tags_map.TagsMap"
+    """<p>The key-value pair to use when tagging this repository.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: TagResourceInput) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    import capo_codecommit.types.tags_map
+
+    out["tags"] = capo_codecommit.types.tags_map.serialize_aws_json_1_1(value["tags"])
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TagResourceInput:
+    out: TagResourceInput = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("TagResourceInput.resource_arn required")
+    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"]
+        )
+    else:
+        raise DeserializationError("TagResourceInput.tags required")
+    return out

capo_codecommit/types/tag_value.py

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

capo_codecommit/types/tags_map.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#TagsMap``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.tag_key
+    import capo_codecommit.types.tag_value
+
+TagsMap: TypeAlias = dict[
+    "capo_codecommit.types.tag_key.TagKey", "capo_codecommit.types.tag_value.TagValue"
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(input_to_serialize: TagsMap) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TagsMap:
+    out: TagsMap = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        out[key] = value
+    return out

capo_codecommit/types/target.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#Target``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.reference_name
+    import capo_codecommit.types.repository_name
+
+
+class Target(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository that contains the pull request.</p>"""
+    source_reference: "capo_codecommit.types.reference_name.ReferenceName"
+    """<p>The branch of the repository that contains the changes for the pull request. Also known as the source branch.</p>"""
+    destination_reference: NotRequired[
+        "capo_codecommit.types.reference_name.ReferenceName"
+    ]
+    """<p>The branch of the repository where the pull request changes are merged. Also known as the destination branch.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: Target) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    out["sourceReference"] = value["source_reference"]
+    if "destination_reference" in value:
+        out["destinationReference"] = value["destination_reference"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> Target:
+    out: Target = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError("Target.repository_name required")
+    if data.get("sourceReference") is not None:
+        out["source_reference"] = data["sourceReference"]
+    else:
+        raise DeserializationError("Target.source_reference required")
+    if data.get("destinationReference") is not None:
+        out["destination_reference"] = data["destinationReference"]
+    return out

capo_codecommit/types/target_list.py

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

capo_codecommit/types/test_repository_triggers_input.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#TestRepositoryTriggersInput``."""
+
+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
+    import capo_codecommit.types.repository_triggers_list
+
+
+class TestRepositoryTriggersInput(TypedDict, closed=True):
+    repository_name: "capo_codecommit.types.repository_name.RepositoryName"
+    """<p>The name of the repository in which to test the triggers.</p>"""
+    triggers: "capo_codecommit.types.repository_triggers_list.RepositoryTriggersList"
+    """<p>The list of triggers to test.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: TestRepositoryTriggersInput) -> dict:
+    out: dict = {}
+    out["repositoryName"] = value["repository_name"]
+    import capo_codecommit.types.repository_triggers_list
+
+    out["triggers"] = (
+        capo_codecommit.types.repository_triggers_list.serialize_aws_json_1_1(
+            value["triggers"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TestRepositoryTriggersInput:
+    out: TestRepositoryTriggersInput = {}  # type: ignore[typeddict-item]
+    if data.get("repositoryName") is not None:
+        out["repository_name"] = data["repositoryName"]
+    else:
+        raise DeserializationError(
+            "TestRepositoryTriggersInput.repository_name required"
+        )
+    if data.get("triggers") is not None:
+        import capo_codecommit.types.repository_triggers_list
+
+        out["triggers"] = (
+            capo_codecommit.types.repository_triggers_list.deserialize_aws_json_1_1(
+                data["triggers"]
+            )
+        )
+    else:
+        raise DeserializationError("TestRepositoryTriggersInput.triggers required")
+    return out

capo_codecommit/types/test_repository_triggers_output.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#TestRepositoryTriggersOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.repository_trigger_execution_failure_list
+    import capo_codecommit.types.repository_trigger_name_list
+
+
+class TestRepositoryTriggersOutput(TypedDict, closed=True):
+    successful_executions: NotRequired[
+        "capo_codecommit.types.repository_trigger_name_list.RepositoryTriggerNameList"
+    ]
+    """<p>The list of triggers that were successfully tested. This list provides the names of the triggers that were successfully tested, separated by commas.</p>"""
+    failed_executions: NotRequired[
+        "capo_codecommit.types.repository_trigger_execution_failure_list.RepositoryTriggerExecutionFailureList"
+    ]
+    """<p>The list of triggers that were not tested. This list provides the names of the triggers that could not be tested, separated by commas.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: TestRepositoryTriggersOutput) -> dict:
+    out: dict = {}
+    if "successful_executions" in value:
+        import capo_codecommit.types.repository_trigger_name_list
+
+        out["successfulExecutions"] = (
+            capo_codecommit.types.repository_trigger_name_list.serialize_aws_json_1_1(
+                value["successful_executions"]
+            )
+        )
+    if "failed_executions" in value:
+        import capo_codecommit.types.repository_trigger_execution_failure_list
+
+        out["failedExecutions"] = (
+            capo_codecommit.types.repository_trigger_execution_failure_list.serialize_aws_json_1_1(
+                value["failed_executions"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> TestRepositoryTriggersOutput:
+    out: TestRepositoryTriggersOutput = {}  # type: ignore[typeddict-item]
+    if data.get("successfulExecutions") is not None:
+        import capo_codecommit.types.repository_trigger_name_list
+
+        out["successful_executions"] = (
+            capo_codecommit.types.repository_trigger_name_list.deserialize_aws_json_1_1(
+                data["successfulExecutions"]
+            )
+        )
+    if data.get("failedExecutions") is not None:
+        import capo_codecommit.types.repository_trigger_execution_failure_list
+
+        out["failed_executions"] = (
+            capo_codecommit.types.repository_trigger_execution_failure_list.deserialize_aws_json_1_1(
+                data["failedExecutions"]
+            )
+        )
+    return out

capo_codecommit/types/title.py

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

capo_codecommit/types/untag_resource_input.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UntagResourceInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codecommit.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecommit.types.resource_arn
+    import capo_codecommit.types.tag_keys_list
+
+
+class UntagResourceInput(TypedDict, closed=True):
+    resource_arn: "capo_codecommit.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the resource to which you want to remove tags.</p>"""
+    tag_keys: "capo_codecommit.types.tag_keys_list.TagKeysList"
+    """<p>The tag key for each tag that you want to remove from the resource.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UntagResourceInput) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    import capo_codecommit.types.tag_keys_list
+
+    out["tagKeys"] = capo_codecommit.types.tag_keys_list.serialize_aws_json_1_1(
+        value["tag_keys"]
+    )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> UntagResourceInput:
+    out: UntagResourceInput = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("UntagResourceInput.resource_arn required")
+    if data.get("tagKeys") is not None:
+        import capo_codecommit.types.tag_keys_list
+
+        out["tag_keys"] = capo_codecommit.types.tag_keys_list.deserialize_aws_json_1_1(
+            data["tagKeys"]
+        )
+    else:
+        raise DeserializationError("UntagResourceInput.tag_keys required")
+    return out

capo_codecommit/types/update_approval_rule_template_content_input.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UpdateApprovalRuleTemplateContentInput``."""
+
+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_content
+    import capo_codecommit.types.approval_rule_template_name
+    import capo_codecommit.types.rule_content_sha256
+
+
+class UpdateApprovalRuleTemplateContentInput(TypedDict, closed=True):
+    approval_rule_template_name: (
+        "capo_codecommit.types.approval_rule_template_name.ApprovalRuleTemplateName"
+    )
+    """<p>The name of the approval rule template where you want to update the content of the rule. </p>"""
+    new_rule_content: "capo_codecommit.types.approval_rule_template_content.ApprovalRuleTemplateContent"
+    """<p>The content that replaces the existing content of the rule. Content statements must be complete. You cannot provide only the changes.</p>"""
+    existing_rule_content_sha256: NotRequired[
+        "capo_codecommit.types.rule_content_sha256.RuleContentSha256"
+    ]
+    """<p>The SHA-256 hash signature for the content of the approval rule. You can retrieve this information by using <a>GetPullRequest</a>.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UpdateApprovalRuleTemplateContentInput) -> dict:
+    out: dict = {}
+    out["approvalRuleTemplateName"] = value["approval_rule_template_name"]
+    out["newRuleContent"] = value["new_rule_content"]
+    if "existing_rule_content_sha256" in value:
+        out["existingRuleContentSha256"] = value["existing_rule_content_sha256"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> UpdateApprovalRuleTemplateContentInput:
+    out: UpdateApprovalRuleTemplateContentInput = {}  # type: ignore[typeddict-item]
+    if data.get("approvalRuleTemplateName") is not None:
+        out["approval_rule_template_name"] = data["approvalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateContentInput.approval_rule_template_name required"
+        )
+    if data.get("newRuleContent") is not None:
+        out["new_rule_content"] = data["newRuleContent"]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateContentInput.new_rule_content required"
+        )
+    if data.get("existingRuleContentSha256") is not None:
+        out["existing_rule_content_sha256"] = data["existingRuleContentSha256"]
+    return out

capo_codecommit/types/update_approval_rule_template_content_output.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UpdateApprovalRuleTemplateContentOutput``."""
+
+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 UpdateApprovalRuleTemplateContentOutput(TypedDict, closed=True):
+    approval_rule_template: (
+        "capo_codecommit.types.approval_rule_template.ApprovalRuleTemplate"
+    )
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UpdateApprovalRuleTemplateContentOutput) -> 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) -> UpdateApprovalRuleTemplateContentOutput:
+    out: UpdateApprovalRuleTemplateContentOutput = {}  # 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(
+            "UpdateApprovalRuleTemplateContentOutput.approval_rule_template required"
+        )
+    return out

capo_codecommit/types/update_approval_rule_template_description_input.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UpdateApprovalRuleTemplateDescriptionInput``."""
+
+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_description
+    import capo_codecommit.types.approval_rule_template_name
+
+
+class UpdateApprovalRuleTemplateDescriptionInput(TypedDict, closed=True):
+    approval_rule_template_name: (
+        "capo_codecommit.types.approval_rule_template_name.ApprovalRuleTemplateName"
+    )
+    """<p>The name of the template for which you want to update the description.</p>"""
+    approval_rule_template_description: "capo_codecommit.types.approval_rule_template_description.ApprovalRuleTemplateDescription"
+    """<p>The updated description of the approval rule template.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UpdateApprovalRuleTemplateDescriptionInput) -> dict:
+    out: dict = {}
+    out["approvalRuleTemplateName"] = value["approval_rule_template_name"]
+    out["approvalRuleTemplateDescription"] = value["approval_rule_template_description"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> UpdateApprovalRuleTemplateDescriptionInput:
+    out: UpdateApprovalRuleTemplateDescriptionInput = {}  # type: ignore[typeddict-item]
+    if data.get("approvalRuleTemplateName") is not None:
+        out["approval_rule_template_name"] = data["approvalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateDescriptionInput.approval_rule_template_name required"
+        )
+    if data.get("approvalRuleTemplateDescription") is not None:
+        out["approval_rule_template_description"] = data[
+            "approvalRuleTemplateDescription"
+        ]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateDescriptionInput.approval_rule_template_description required"
+        )
+    return out

capo_codecommit/types/update_approval_rule_template_description_output.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UpdateApprovalRuleTemplateDescriptionOutput``."""
+
+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 UpdateApprovalRuleTemplateDescriptionOutput(TypedDict, closed=True):
+    approval_rule_template: (
+        "capo_codecommit.types.approval_rule_template.ApprovalRuleTemplate"
+    )
+    """<p>The structure and content of the updated approval rule template.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UpdateApprovalRuleTemplateDescriptionOutput) -> 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) -> UpdateApprovalRuleTemplateDescriptionOutput:
+    out: UpdateApprovalRuleTemplateDescriptionOutput = {}  # 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(
+            "UpdateApprovalRuleTemplateDescriptionOutput.approval_rule_template required"
+        )
+    return out

capo_codecommit/types/update_approval_rule_template_name_input.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.codecommit#UpdateApprovalRuleTemplateNameInput``."""
+
+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 UpdateApprovalRuleTemplateNameInput(TypedDict, closed=True):
+    old_approval_rule_template_name: (
+        "capo_codecommit.types.approval_rule_template_name.ApprovalRuleTemplateName"
+    )
+    """<p>The current name of the approval rule template.</p>"""
+    new_approval_rule_template_name: (
+        "capo_codecommit.types.approval_rule_template_name.ApprovalRuleTemplateName"
+    )
+    """<p>The new name you want to apply to the approval rule template.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: UpdateApprovalRuleTemplateNameInput) -> dict:
+    out: dict = {}
+    out["oldApprovalRuleTemplateName"] = value["old_approval_rule_template_name"]
+    out["newApprovalRuleTemplateName"] = value["new_approval_rule_template_name"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> UpdateApprovalRuleTemplateNameInput:
+    out: UpdateApprovalRuleTemplateNameInput = {}  # type: ignore[typeddict-item]
+    if data.get("oldApprovalRuleTemplateName") is not None:
+        out["old_approval_rule_template_name"] = data["oldApprovalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateNameInput.old_approval_rule_template_name required"
+        )
+    if data.get("newApprovalRuleTemplateName") is not None:
+        out["new_approval_rule_template_name"] = data["newApprovalRuleTemplateName"]
+    else:
+        raise DeserializationError(
+            "UpdateApprovalRuleTemplateNameInput.new_approval_rule_template_name required"
+        )
+    return out