capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/types/tag_resource_request.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+from capo_cloudfront.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.resource_arn
+    import capo_cloudfront.types.tags
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource: "capo_cloudfront.types.resource_arn.ResourceARN"
+    """<p>An ARN of a CloudFront resource.</p>"""
+    tags: "capo_cloudfront.types.tags.Tags"
+    """<p>A complex type that contains zero or more <code>Tag</code> elements.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TagResourceRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.tags
+
+    capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+
+
+def deserialize_xml(el: Element) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    child_tags = el.find("Tags")
+    if child_tags is not None:
+        import capo_cloudfront.types.tags
+
+        out["tags"] = capo_cloudfront.types.tags.deserialize_xml(child_tags)
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_cloudfront/types/tag_value.py

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

capo_cloudfront/types/tags.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#Tags``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.tag_list
+
+
+class Tags(TypedDict, closed=True):
+    items: NotRequired["capo_cloudfront.types.tag_list.TagList"]
+    """<p>A complex type that contains <code>Tag</code> elements.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: Tags, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "items" in value:
+        import capo_cloudfront.types.tag_list
+
+        capo_cloudfront.types.tag_list.serialize_xml(value["items"], el, "Items")
+
+
+def deserialize_xml(el: Element) -> Tags:
+    out: Tags = {}  # type: ignore[typeddict-item]
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.tag_list
+
+        out["items"] = capo_cloudfront.types.tag_list.deserialize_xml(child_items)
+    return out

capo_cloudfront/types/tenant_config.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TenantConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.parameter_definitions
+
+
+class TenantConfig(TypedDict, closed=True):
+    parameter_definitions: NotRequired[
+        "capo_cloudfront.types.parameter_definitions.ParameterDefinitions"
+    ]
+    """<p>The parameters that you specify for a distribution tenant.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TenantConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "parameter_definitions" in value:
+        import capo_cloudfront.types.parameter_definitions
+
+        capo_cloudfront.types.parameter_definitions.serialize_xml(
+            value["parameter_definitions"], el, "ParameterDefinitions"
+        )
+
+
+def deserialize_xml(el: Element) -> TenantConfig:
+    out: TenantConfig = {}  # type: ignore[typeddict-item]
+    child_parameter_definitions = el.find("ParameterDefinitions")
+    if child_parameter_definitions is not None:
+        import capo_cloudfront.types.parameter_definitions
+
+        out["parameter_definitions"] = (
+            capo_cloudfront.types.parameter_definitions.deserialize_xml(
+                child_parameter_definitions
+            )
+        )
+    return out

capo_cloudfront/types/test_connection_function_request.py

@@ -0,0 +1,64 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TestConnectionFunctionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+from capo_cloudfront.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.function_event_object
+    import capo_cloudfront.types.function_stage
+    import capo_cloudfront.types.resource_id
+    import capo_cloudfront.types.string
+
+
+class TestConnectionFunctionRequest(TypedDict, closed=True):
+    id: "capo_cloudfront.types.resource_id.ResourceId"
+    """<p>The connection function ID.</p>"""
+    if_match: "capo_cloudfront.types.string.string"
+    """<p>The current version (<code>ETag</code> value) of the connection function.</p>"""
+    stage: NotRequired["capo_cloudfront.types.function_stage.FunctionStage"]
+    """<p>The connection function stage.</p>"""
+    connection_object: "capo_cloudfront.types.function_event_object.FunctionEventObject"
+    """<p>The connection object.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: TestConnectionFunctionRequest, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    if "stage" in value:
+        import capo_cloudfront.types.function_stage
+
+        capo_cloudfront.types.function_stage.serialize_xml(value["stage"], el, "Stage")
+    import capo_cloudfront.types.function_event_object
+
+    capo_cloudfront.types.function_event_object.serialize_xml(
+        value["connection_object"], el, "ConnectionObject"
+    )
+
+
+def deserialize_xml(el: Element) -> TestConnectionFunctionRequest:
+    out: TestConnectionFunctionRequest = {}  # type: ignore[typeddict-item]
+    child_stage = el.find("Stage")
+    if child_stage is not None:
+        import capo_cloudfront.types.function_stage
+
+        out["stage"] = capo_cloudfront.types.function_stage.deserialize_xml(child_stage)
+    child_connection_object = el.find("ConnectionObject")
+    if child_connection_object is not None:
+        import capo_cloudfront.types.function_event_object
+
+        out["connection_object"] = (
+            capo_cloudfront.types.function_event_object.deserialize_xml(
+                child_connection_object
+            )
+        )
+    else:
+        raise DeserializationError(
+            "TestConnectionFunctionRequest.connection_object required"
+        )
+    return out

capo_cloudfront/types/test_connection_function_result.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TestConnectionFunctionResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.connection_function_test_result
+
+
+class TestConnectionFunctionResult(TypedDict, closed=True):
+    connection_function_test_result: NotRequired[
+        "capo_cloudfront.types.connection_function_test_result.ConnectionFunctionTestResult"
+    ]
+    """<p>The connection function test result.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: TestConnectionFunctionResult, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    if "connection_function_test_result" in value:
+        import capo_cloudfront.types.connection_function_test_result
+
+        capo_cloudfront.types.connection_function_test_result.serialize_xml(
+            value["connection_function_test_result"], el, "ConnectionFunctionTestResult"
+        )
+
+
+def deserialize_xml(el: Element) -> TestConnectionFunctionResult:
+    out: TestConnectionFunctionResult = {}  # type: ignore[typeddict-item]
+    child_connection_function_test_result = el.find("ConnectionFunctionTestResult")
+    if child_connection_function_test_result is not None:
+        import capo_cloudfront.types.connection_function_test_result
+
+        out["connection_function_test_result"] = (
+            capo_cloudfront.types.connection_function_test_result.deserialize_xml(
+                child_connection_function_test_result
+            )
+        )
+    return out

capo_cloudfront/types/test_function_request.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TestFunctionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+from capo_cloudfront.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.function_event_object
+    import capo_cloudfront.types.function_name
+    import capo_cloudfront.types.function_stage
+    import capo_cloudfront.types.string
+
+
+class TestFunctionRequest(TypedDict, closed=True):
+    name: "capo_cloudfront.types.function_name.FunctionName"
+    """<p>The name of the function that you are testing.</p>"""
+    if_match: "capo_cloudfront.types.string.string"
+    """<p>The current version (<code>ETag</code> value) of the function that you are testing, which you can get using <code>DescribeFunction</code>.</p>"""
+    stage: NotRequired["capo_cloudfront.types.function_stage.FunctionStage"]
+    """<p>The stage of the function that you are testing, either <code>DEVELOPMENT</code> or <code>LIVE</code>.</p>"""
+    event_object: "capo_cloudfront.types.function_event_object.FunctionEventObject"
+    r"""<p>The event object to test the function with. For more information about the structure of the event object, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/managing-functions.html#test-function\">Testing functions</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TestFunctionRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "stage" in value:
+        import capo_cloudfront.types.function_stage
+
+        capo_cloudfront.types.function_stage.serialize_xml(value["stage"], el, "Stage")
+    import capo_cloudfront.types.function_event_object
+
+    capo_cloudfront.types.function_event_object.serialize_xml(
+        value["event_object"], el, "EventObject"
+    )
+
+
+def deserialize_xml(el: Element) -> TestFunctionRequest:
+    out: TestFunctionRequest = {}  # type: ignore[typeddict-item]
+    child_stage = el.find("Stage")
+    if child_stage is not None:
+        import capo_cloudfront.types.function_stage
+
+        out["stage"] = capo_cloudfront.types.function_stage.deserialize_xml(child_stage)
+    child_event_object = el.find("EventObject")
+    if child_event_object is not None:
+        import capo_cloudfront.types.function_event_object
+
+        out["event_object"] = (
+            capo_cloudfront.types.function_event_object.deserialize_xml(
+                child_event_object
+            )
+        )
+    else:
+        raise DeserializationError("TestFunctionRequest.event_object required")
+    return out

capo_cloudfront/types/test_function_result.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TestFunctionResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.test_result
+
+
+class TestFunctionResult(TypedDict, closed=True):
+    test_result: NotRequired["capo_cloudfront.types.test_result.TestResult"]
+    """<p>An object that represents the result of running the function with the provided event object.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TestFunctionResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "test_result" in value:
+        import capo_cloudfront.types.test_result
+
+        capo_cloudfront.types.test_result.serialize_xml(
+            value["test_result"], el, "TestResult"
+        )
+
+
+def deserialize_xml(el: Element) -> TestFunctionResult:
+    out: TestFunctionResult = {}  # type: ignore[typeddict-item]
+    child_test_result = el.find("TestResult")
+    if child_test_result is not None:
+        import capo_cloudfront.types.test_result
+
+        out["test_result"] = capo_cloudfront.types.test_result.deserialize_xml(
+            child_test_result
+        )
+    return out

capo_cloudfront/types/test_result.py

@@ -0,0 +1,91 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TestResult``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.function_execution_log_list
+    import capo_cloudfront.types.function_summary
+    import capo_cloudfront.types.sensitive_string_type
+    import capo_cloudfront.types.string
+
+
+class TestResult(TypedDict, closed=True):
+    function_summary: NotRequired[
+        "capo_cloudfront.types.function_summary.FunctionSummary"
+    ]
+    """<p>Contains configuration information and metadata about the CloudFront function that was tested.</p>"""
+    compute_utilization: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The amount of time that the function took to run as a percentage of the maximum allowed time. For example, a compute utilization of 35 means that the function completed in 35% of the maximum allowed time.</p>"""
+    function_execution_logs: NotRequired[
+        "capo_cloudfront.types.function_execution_log_list.FunctionExecutionLogList"
+    ]
+    """<p>Contains the log lines that the function wrote (if any) when running the test.</p>"""
+    function_error_message: NotRequired[
+        "capo_cloudfront.types.sensitive_string_type.sensitiveStringType"
+    ]
+    """<p>If the result of testing the function was an error, this field contains the error message.</p>"""
+    function_output: NotRequired[
+        "capo_cloudfront.types.sensitive_string_type.sensitiveStringType"
+    ]
+    r"""<p>The event object returned by the function. For more information about the structure of the event object, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-event-structure.html\">Event object structure</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TestResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "function_summary" in value:
+        import capo_cloudfront.types.function_summary
+
+        capo_cloudfront.types.function_summary.serialize_xml(
+            value["function_summary"], el, "FunctionSummary"
+        )
+    if "compute_utilization" in value:
+        SubElement(el, "ComputeUtilization").text = str(value["compute_utilization"])
+    if "function_execution_logs" in value:
+        import capo_cloudfront.types.function_execution_log_list
+
+        capo_cloudfront.types.function_execution_log_list.serialize_xml(
+            value["function_execution_logs"], el, "FunctionExecutionLogs"
+        )
+    if "function_error_message" in value:
+        SubElement(el, "FunctionErrorMessage").text = str(
+            value["function_error_message"]
+        )
+    if "function_output" in value:
+        SubElement(el, "FunctionOutput").text = str(value["function_output"])
+
+
+def deserialize_xml(el: Element) -> TestResult:
+    out: TestResult = {}  # type: ignore[typeddict-item]
+    child_function_summary = el.find("FunctionSummary")
+    if child_function_summary is not None:
+        import capo_cloudfront.types.function_summary
+
+        out["function_summary"] = (
+            capo_cloudfront.types.function_summary.deserialize_xml(
+                child_function_summary
+            )
+        )
+    child_compute_utilization = el.find("ComputeUtilization")
+    if child_compute_utilization is not None:
+        out["compute_utilization"] = str(child_compute_utilization.text or "")
+    child_function_execution_logs = el.find("FunctionExecutionLogs")
+    if child_function_execution_logs is not None:
+        import capo_cloudfront.types.function_execution_log_list
+
+        out["function_execution_logs"] = (
+            capo_cloudfront.types.function_execution_log_list.deserialize_xml(
+                child_function_execution_logs
+            )
+        )
+    child_function_error_message = el.find("FunctionErrorMessage")
+    if child_function_error_message is not None:
+        out["function_error_message"] = str(child_function_error_message.text or "")
+    child_function_output = el.find("FunctionOutput")
+    if child_function_output is not None:
+        out["function_output"] = str(child_function_output.text or "")
+    return out

capo_cloudfront/types/timestamp.py

@@ -0,0 +1,25 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#timestamp``."""
+
+import datetime
+from typing import TypeAlias
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+timestamp: TypeAlias = datetime.datetime
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: timestamp) -> str:
+    return value.isoformat()
+
+
+def from_xml_text(text: str) -> timestamp:
+    return datetime.datetime.fromisoformat(text.replace("Z", "+00:00"))
+
+
+def serialize_xml(value: timestamp, parent: Element, tag: str) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> timestamp:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/traffic_config.py

@@ -0,0 +1,82 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TrafficConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+from capo_cloudfront.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.continuous_deployment_policy_type
+    import capo_cloudfront.types.continuous_deployment_single_header_config
+    import capo_cloudfront.types.continuous_deployment_single_weight_config
+
+
+class TrafficConfig(TypedDict, closed=True):
+    single_weight_config: NotRequired[
+        "capo_cloudfront.types.continuous_deployment_single_weight_config.ContinuousDeploymentSingleWeightConfig"
+    ]
+    """<p>Contains the percentage of traffic to send to the staging distribution.</p>"""
+    single_header_config: NotRequired[
+        "capo_cloudfront.types.continuous_deployment_single_header_config.ContinuousDeploymentSingleHeaderConfig"
+    ]
+    """<p>Determines which HTTP requests are sent to the staging distribution.</p>"""
+    type: "capo_cloudfront.types.continuous_deployment_policy_type.ContinuousDeploymentPolicyType"
+    """<p>The type of traffic configuration.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TrafficConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "single_weight_config" in value:
+        import capo_cloudfront.types.continuous_deployment_single_weight_config
+
+        capo_cloudfront.types.continuous_deployment_single_weight_config.serialize_xml(
+            value["single_weight_config"], el, "SingleWeightConfig"
+        )
+    if "single_header_config" in value:
+        import capo_cloudfront.types.continuous_deployment_single_header_config
+
+        capo_cloudfront.types.continuous_deployment_single_header_config.serialize_xml(
+            value["single_header_config"], el, "SingleHeaderConfig"
+        )
+    import capo_cloudfront.types.continuous_deployment_policy_type
+
+    capo_cloudfront.types.continuous_deployment_policy_type.serialize_xml(
+        value["type"], el, "Type"
+    )
+
+
+def deserialize_xml(el: Element) -> TrafficConfig:
+    out: TrafficConfig = {}  # type: ignore[typeddict-item]
+    child_single_weight_config = el.find("SingleWeightConfig")
+    if child_single_weight_config is not None:
+        import capo_cloudfront.types.continuous_deployment_single_weight_config
+
+        out["single_weight_config"] = (
+            capo_cloudfront.types.continuous_deployment_single_weight_config.deserialize_xml(
+                child_single_weight_config
+            )
+        )
+    child_single_header_config = el.find("SingleHeaderConfig")
+    if child_single_header_config is not None:
+        import capo_cloudfront.types.continuous_deployment_single_header_config
+
+        out["single_header_config"] = (
+            capo_cloudfront.types.continuous_deployment_single_header_config.deserialize_xml(
+                child_single_header_config
+            )
+        )
+    child_type = el.find("Type")
+    if child_type is not None:
+        import capo_cloudfront.types.continuous_deployment_policy_type
+
+        out["type"] = (
+            capo_cloudfront.types.continuous_deployment_policy_type.deserialize_xml(
+                child_type
+            )
+        )
+    else:
+        raise DeserializationError("TrafficConfig.type required")
+    return out

capo_cloudfront/types/trust_store.py

@@ -0,0 +1,111 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#TrustStore``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.boolean
+    import capo_cloudfront.types.integer
+    import capo_cloudfront.types.string
+    import capo_cloudfront.types.timestamp
+    import capo_cloudfront.types.trust_store_status
+
+
+class TrustStore(TypedDict, closed=True):
+    id: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The trust store's ID.</p>"""
+    arn: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The trust store's Amazon Resource Name (ARN).</p>"""
+    name: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The trust store's name.</p>"""
+    status: NotRequired["capo_cloudfront.types.trust_store_status.TrustStoreStatus"]
+    """<p>The trust store's status.</p>"""
+    number_of_ca_certificates: NotRequired["capo_cloudfront.types.integer.integer"]
+    """<p>The trust store's number of CA certificates.</p>"""
+    last_modified_time: NotRequired["capo_cloudfront.types.timestamp.timestamp"]
+    """<p>The trust store's last modified time.</p>"""
+    reason: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The trust store's reason.</p>"""
+    use_client_certificate_ocsp_endpoint: NotRequired[
+        "capo_cloudfront.types.boolean.boolean"
+    ]
+    """<p>A Boolean that determines whether the trust store uses the CA certificate's OCSP endpoint to check certificate revocation status.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: TrustStore, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "id" in value:
+        SubElement(el, "Id").text = str(value["id"])
+    if "arn" in value:
+        SubElement(el, "Arn").text = str(value["arn"])
+    if "name" in value:
+        SubElement(el, "Name").text = str(value["name"])
+    if "status" in value:
+        import capo_cloudfront.types.trust_store_status
+
+        capo_cloudfront.types.trust_store_status.serialize_xml(
+            value["status"], el, "Status"
+        )
+    if "number_of_ca_certificates" in value:
+        SubElement(el, "NumberOfCaCertificates").text = str(
+            value["number_of_ca_certificates"]
+        )
+    if "last_modified_time" in value:
+        import capo_cloudfront.types.timestamp
+
+        capo_cloudfront.types.timestamp.serialize_xml(
+            value["last_modified_time"], el, "LastModifiedTime"
+        )
+    if "reason" in value:
+        SubElement(el, "Reason").text = str(value["reason"])
+    if "use_client_certificate_ocsp_endpoint" in value:
+        SubElement(el, "UseClientCertificateOCSPEndpoint").text = (
+            "true" if value["use_client_certificate_ocsp_endpoint"] else "false"
+        )
+
+
+def deserialize_xml(el: Element) -> TrustStore:
+    out: TrustStore = {}  # type: ignore[typeddict-item]
+    child_id = el.find("Id")
+    if child_id is not None:
+        out["id"] = str(child_id.text or "")
+    child_arn = el.find("Arn")
+    if child_arn is not None:
+        out["arn"] = str(child_arn.text or "")
+    child_name = el.find("Name")
+    if child_name is not None:
+        out["name"] = str(child_name.text or "")
+    child_status = el.find("Status")
+    if child_status is not None:
+        import capo_cloudfront.types.trust_store_status
+
+        out["status"] = capo_cloudfront.types.trust_store_status.deserialize_xml(
+            child_status
+        )
+    child_number_of_ca_certificates = el.find("NumberOfCaCertificates")
+    if child_number_of_ca_certificates is not None:
+        out["number_of_ca_certificates"] = int(
+            child_number_of_ca_certificates.text or ""
+        )
+    child_last_modified_time = el.find("LastModifiedTime")
+    if child_last_modified_time is not None:
+        import capo_cloudfront.types.timestamp
+
+        out["last_modified_time"] = capo_cloudfront.types.timestamp.deserialize_xml(
+            child_last_modified_time
+        )
+    child_reason = el.find("Reason")
+    if child_reason is not None:
+        out["reason"] = str(child_reason.text or "")
+    child_use_client_certificate_ocsp_endpoint = el.find(
+        "UseClientCertificateOCSPEndpoint"
+    )
+    if child_use_client_certificate_ocsp_endpoint is not None:
+        out["use_client_certificate_ocsp_endpoint"] = (
+            child_use_client_certificate_ocsp_endpoint.text or ""
+        ).lower() == "true"
+    return out