capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/types/cache_policy_header_behavior.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyHeaderBehavior``."""
+
+from typing import Literal, TypeAlias, cast
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+CachePolicyHeaderBehavior: TypeAlias = Literal[
+    "none",
+    "whitelist",
+]
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: CachePolicyHeaderBehavior) -> str:
+    return value
+
+
+def from_xml_text(text: str) -> CachePolicyHeaderBehavior:
+    return cast(CachePolicyHeaderBehavior, text)
+
+
+def serialize_xml(value: CachePolicyHeaderBehavior, parent: Element, tag: str) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> CachePolicyHeaderBehavior:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/cache_policy_headers_config.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyHeadersConfig``."""
+
+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.cache_policy_header_behavior
+    import capo_cloudfront.types.headers
+
+
+class CachePolicyHeadersConfig(TypedDict, closed=True):
+    header_behavior: (
+        "capo_cloudfront.types.cache_policy_header_behavior.CachePolicyHeaderBehavior"
+    )
+    """<p>Determines whether any HTTP headers are included in the cache key and in requests that CloudFront sends to the origin. Valid values are:</p> <ul> <li> <p> <code>none</code> – No HTTP headers are included in the cache key or in requests that CloudFront sends to the origin. Even when this field is set to <code>none</code>, any headers that are listed in an <code>OriginRequestPolicy</code> <i>are</i> included in origin requests.</p> </li> <li> <p> <code>whitelist</code> – Only the HTTP headers that are listed in the <code>Headers</code> type are included in the cache key and in requests that CloudFront sends to the origin.</p> </li> </ul>"""
+    headers: NotRequired["capo_cloudfront.types.headers.Headers"]
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CachePolicyHeadersConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.cache_policy_header_behavior
+
+    capo_cloudfront.types.cache_policy_header_behavior.serialize_xml(
+        value["header_behavior"], el, "HeaderBehavior"
+    )
+    if "headers" in value:
+        import capo_cloudfront.types.headers
+
+        capo_cloudfront.types.headers.serialize_xml(value["headers"], el, "Headers")
+
+
+def deserialize_xml(el: Element) -> CachePolicyHeadersConfig:
+    out: CachePolicyHeadersConfig = {}  # type: ignore[typeddict-item]
+    child_header_behavior = el.find("HeaderBehavior")
+    if child_header_behavior is not None:
+        import capo_cloudfront.types.cache_policy_header_behavior
+
+        out["header_behavior"] = (
+            capo_cloudfront.types.cache_policy_header_behavior.deserialize_xml(
+                child_header_behavior
+            )
+        )
+    else:
+        raise DeserializationError("CachePolicyHeadersConfig.header_behavior required")
+    child_headers = el.find("Headers")
+    if child_headers is not None:
+        import capo_cloudfront.types.headers
+
+        out["headers"] = capo_cloudfront.types.headers.deserialize_xml(child_headers)
+    return out

capo_cloudfront/types/cache_policy_list.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyList``."""
+
+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.cache_policy_summary_list
+    import capo_cloudfront.types.integer
+    import capo_cloudfront.types.string
+
+
+class CachePolicyList(TypedDict, closed=True):
+    next_marker: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>If there are more items in the list than are in this response, this element is present. It contains the value that you should use in the <code>Marker</code> field of a subsequent request to continue listing cache policies where you left off.</p>"""
+    max_items: "capo_cloudfront.types.integer.integer"
+    """<p>The maximum number of cache policies requested.</p>"""
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>The total number of cache policies returned in the response.</p>"""
+    items: NotRequired[
+        "capo_cloudfront.types.cache_policy_summary_list.CachePolicySummaryList"
+    ]
+    """<p>Contains the cache policies in the list.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CachePolicyList, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "next_marker" in value:
+        SubElement(el, "NextMarker").text = str(value["next_marker"])
+    SubElement(el, "MaxItems").text = str(value["max_items"])
+    SubElement(el, "Quantity").text = str(value["quantity"])
+    if "items" in value:
+        import capo_cloudfront.types.cache_policy_summary_list
+
+        capo_cloudfront.types.cache_policy_summary_list.serialize_xml(
+            value["items"], el, "Items"
+        )
+
+
+def deserialize_xml(el: Element) -> CachePolicyList:
+    out: CachePolicyList = {}  # type: ignore[typeddict-item]
+    child_next_marker = el.find("NextMarker")
+    if child_next_marker is not None:
+        out["next_marker"] = str(child_next_marker.text or "")
+    child_max_items = el.find("MaxItems")
+    if child_max_items is not None:
+        out["max_items"] = int(child_max_items.text or "")
+    else:
+        raise DeserializationError("CachePolicyList.max_items required")
+    child_quantity = el.find("Quantity")
+    if child_quantity is not None:
+        out["quantity"] = int(child_quantity.text or "")
+    else:
+        raise DeserializationError("CachePolicyList.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.cache_policy_summary_list
+
+        out["items"] = capo_cloudfront.types.cache_policy_summary_list.deserialize_xml(
+            child_items
+        )
+    return out

capo_cloudfront/types/cache_policy_query_string_behavior.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyQueryStringBehavior``."""
+
+from typing import Literal, TypeAlias, cast
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+CachePolicyQueryStringBehavior: TypeAlias = Literal[
+    "none",
+    "whitelist",
+    "allExcept",
+    "all",
+]
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: CachePolicyQueryStringBehavior) -> str:
+    return value
+
+
+def from_xml_text(text: str) -> CachePolicyQueryStringBehavior:
+    return cast(CachePolicyQueryStringBehavior, text)
+
+
+def serialize_xml(
+    value: CachePolicyQueryStringBehavior, parent: Element, tag: str
+) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> CachePolicyQueryStringBehavior:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/cache_policy_query_strings_config.py

@@ -0,0 +1,64 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyQueryStringsConfig``."""
+
+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.cache_policy_query_string_behavior
+    import capo_cloudfront.types.query_string_names
+
+
+class CachePolicyQueryStringsConfig(TypedDict, closed=True):
+    query_string_behavior: "capo_cloudfront.types.cache_policy_query_string_behavior.CachePolicyQueryStringBehavior"
+    """<p>Determines whether any URL query strings in viewer requests are included in the cache key and in requests that CloudFront sends to the origin. Valid values are:</p> <ul> <li> <p> <code>none</code> – No query strings in viewer requests are included in the cache key or in requests that CloudFront sends to the origin. Even when this field is set to <code>none</code>, any query strings that are listed in an <code>OriginRequestPolicy</code> <i>are</i> included in origin requests.</p> </li> <li> <p> <code>whitelist</code> – Only the query strings in viewer requests that are listed in the <code>QueryStringNames</code> type are included in the cache key and in requests that CloudFront sends to the origin.</p> </li> <li> <p> <code>allExcept</code> – All query strings in viewer requests are included in the cache key and in requests that CloudFront sends to the origin, <i> <b>except</b> </i> those that are listed in the <code>QueryStringNames</code> type, which are not included.</p> </li> <li> <p> <code>all</code> – All query strings in viewer requests are included in the cache key and in requests that CloudFront sends to the origin.</p> </li> </ul>"""
+    query_strings: NotRequired[
+        "capo_cloudfront.types.query_string_names.QueryStringNames"
+    ]
+    """<p>Contains the specific query strings in viewer requests that either <i> <b>are</b> </i> or <i> <b>are not</b> </i> included in the cache key and in requests that CloudFront sends to the origin. The behavior depends on whether the <code>QueryStringBehavior</code> field in the <code>CachePolicyQueryStringsConfig</code> type is set to <code>whitelist</code> (the listed query strings <i> <b>are</b> </i> included) or <code>allExcept</code> (the listed query strings <i> <b>are not</b> </i> included, but all other query strings are).</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CachePolicyQueryStringsConfig, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.cache_policy_query_string_behavior
+
+    capo_cloudfront.types.cache_policy_query_string_behavior.serialize_xml(
+        value["query_string_behavior"], el, "QueryStringBehavior"
+    )
+    if "query_strings" in value:
+        import capo_cloudfront.types.query_string_names
+
+        capo_cloudfront.types.query_string_names.serialize_xml(
+            value["query_strings"], el, "QueryStrings"
+        )
+
+
+def deserialize_xml(el: Element) -> CachePolicyQueryStringsConfig:
+    out: CachePolicyQueryStringsConfig = {}  # type: ignore[typeddict-item]
+    child_query_string_behavior = el.find("QueryStringBehavior")
+    if child_query_string_behavior is not None:
+        import capo_cloudfront.types.cache_policy_query_string_behavior
+
+        out["query_string_behavior"] = (
+            capo_cloudfront.types.cache_policy_query_string_behavior.deserialize_xml(
+                child_query_string_behavior
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CachePolicyQueryStringsConfig.query_string_behavior required"
+        )
+    child_query_strings = el.find("QueryStrings")
+    if child_query_strings is not None:
+        import capo_cloudfront.types.query_string_names
+
+        out["query_strings"] = capo_cloudfront.types.query_string_names.deserialize_xml(
+            child_query_strings
+        )
+    return out

capo_cloudfront/types/cache_policy_summary.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicySummary``."""
+
+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.cache_policy
+    import capo_cloudfront.types.cache_policy_type
+
+
+class CachePolicySummary(TypedDict, closed=True):
+    type: "capo_cloudfront.types.cache_policy_type.CachePolicyType"
+    """<p>The type of cache policy, either <code>managed</code> (created by Amazon Web Services) or <code>custom</code> (created in this Amazon Web Services account).</p>"""
+    cache_policy: "capo_cloudfront.types.cache_policy.CachePolicy"
+    """<p>The cache policy.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CachePolicySummary, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.cache_policy_type
+
+    capo_cloudfront.types.cache_policy_type.serialize_xml(value["type"], el, "Type")
+    import capo_cloudfront.types.cache_policy
+
+    capo_cloudfront.types.cache_policy.serialize_xml(
+        value["cache_policy"], el, "CachePolicy"
+    )
+
+
+def deserialize_xml(el: Element) -> CachePolicySummary:
+    out: CachePolicySummary = {}  # type: ignore[typeddict-item]
+    child_type = el.find("Type")
+    if child_type is not None:
+        import capo_cloudfront.types.cache_policy_type
+
+        out["type"] = capo_cloudfront.types.cache_policy_type.deserialize_xml(
+            child_type
+        )
+    else:
+        raise DeserializationError("CachePolicySummary.type required")
+    child_cache_policy = el.find("CachePolicy")
+    if child_cache_policy is not None:
+        import capo_cloudfront.types.cache_policy
+
+        out["cache_policy"] = capo_cloudfront.types.cache_policy.deserialize_xml(
+            child_cache_policy
+        )
+    else:
+        raise DeserializationError("CachePolicySummary.cache_policy required")
+    return out

capo_cloudfront/types/cache_policy_summary_list.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicySummaryList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.cache_policy_summary
+
+CachePolicySummaryList: TypeAlias = list[
+    "capo_cloudfront.types.cache_policy_summary.CachePolicySummary"
+]
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CachePolicySummaryList, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    for item in value:
+        import capo_cloudfront.types.cache_policy_summary
+
+        capo_cloudfront.types.cache_policy_summary.serialize_xml(
+            item, el, "CachePolicySummary"
+        )
+
+
+def deserialize_xml(el: Element) -> CachePolicySummaryList:
+    import capo_cloudfront.types.cache_policy_summary
+
+    out: CachePolicySummaryList = []
+    for child in el.findall("CachePolicySummary"):
+        out.append(capo_cloudfront.types.cache_policy_summary.deserialize_xml(child))
+    return out
+
+
+def serialize_xml_flat(
+    value: CachePolicySummaryList, parent: Element, tag: str
+) -> None:
+    """Variant used by parent structures with ``@xmlFlattened`` on the referencing member. Items emitted directly under ``parent``."""
+    for item in value:
+        import capo_cloudfront.types.cache_policy_summary
+
+        capo_cloudfront.types.cache_policy_summary.serialize_xml(item, parent, tag)
+
+
+def deserialize_xml_flat(parent: Element, tag: str) -> CachePolicySummaryList:
+    import capo_cloudfront.types.cache_policy_summary
+
+    out: CachePolicySummaryList = []
+    for child in parent.findall(tag):
+        out.append(capo_cloudfront.types.cache_policy_summary.deserialize_xml(child))
+    return out

capo_cloudfront/types/cache_policy_type.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachePolicyType``."""
+
+from typing import Literal, TypeAlias, cast
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+CachePolicyType: TypeAlias = Literal[
+    "managed",
+    "custom",
+]
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: CachePolicyType) -> str:
+    return value
+
+
+def from_xml_text(text: str) -> CachePolicyType:
+    return cast(CachePolicyType, text)
+
+
+def serialize_xml(value: CachePolicyType, parent: Element, tag: str) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> CachePolicyType:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/cache_tag_config.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CacheTagConfig``."""
+
+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.string
+
+
+class CacheTagConfig(TypedDict, closed=True):
+    header_name: "capo_cloudfront.types.string.string"
+    """<p>The name of the HTTP header that your origin includes in responses. CloudFront uses this header to extract cache tags. The header value must contain comma-separated tag values (for example, <code>product:electronics, category:tv, brand:example</code>).</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CacheTagConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "HeaderName").text = str(value["header_name"])
+
+
+def deserialize_xml(el: Element) -> CacheTagConfig:
+    out: CacheTagConfig = {}  # type: ignore[typeddict-item]
+    child_header_name = el.find("HeaderName")
+    if child_header_name is not None:
+        out["header_name"] = str(child_header_name.text or "")
+    else:
+        raise DeserializationError("CacheTagConfig.header_name required")
+    return out

capo_cloudfront/types/cached_methods.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CachedMethods``."""
+
+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.integer
+    import capo_cloudfront.types.methods_list
+
+
+class CachedMethods(TypedDict, closed=True):
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>The number of HTTP methods for which you want CloudFront to cache responses. Valid values are <code>2</code> (for caching responses to <code>GET</code> and <code>HEAD</code> requests) and <code>3</code> (for caching responses to <code>GET</code>, <code>HEAD</code>, and <code>OPTIONS</code> requests).</p>"""
+    items: "capo_cloudfront.types.methods_list.MethodsList"
+    """<p>A complex type that contains the HTTP methods that you want CloudFront to cache responses to. Valid values for <code>CachedMethods</code> include <code>GET</code>, <code>HEAD</code>, and <code>OPTIONS</code>, depending on which caching option you choose. For more information, see the preceding section.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CachedMethods, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Quantity").text = str(value["quantity"])
+    import capo_cloudfront.types.methods_list
+
+    capo_cloudfront.types.methods_list.serialize_xml(value["items"], el, "Items")
+
+
+def deserialize_xml(el: Element) -> CachedMethods:
+    out: CachedMethods = {}  # type: ignore[typeddict-item]
+    child_quantity = el.find("Quantity")
+    if child_quantity is not None:
+        out["quantity"] = int(child_quantity.text or "")
+    else:
+        raise DeserializationError("CachedMethods.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.methods_list
+
+        out["items"] = capo_cloudfront.types.methods_list.deserialize_xml(child_items)
+    else:
+        raise DeserializationError("CachedMethods.items required")
+    return out

capo_cloudfront/types/certificate.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#Certificate``."""
+
+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.string
+
+
+class Certificate(TypedDict, closed=True):
+    arn: "capo_cloudfront.types.string.string"
+    """<p>The Amazon Resource Name (ARN) of the ACM certificate.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: Certificate, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Arn").text = str(value["arn"])
+
+
+def deserialize_xml(el: Element) -> Certificate:
+    out: Certificate = {}  # type: ignore[typeddict-item]
+    child_arn = el.find("Arn")
+    if child_arn is not None:
+        out["arn"] = str(child_arn.text or "")
+    else:
+        raise DeserializationError("Certificate.arn required")
+    return out

capo_cloudfront/types/certificate_source.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CertificateSource``."""
+
+from typing import Literal, TypeAlias, cast
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+CertificateSource: TypeAlias = Literal[
+    "cloudfront",
+    "iam",
+    "acm",
+]
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: CertificateSource) -> str:
+    return value
+
+
+def from_xml_text(text: str) -> CertificateSource:
+    return cast(CertificateSource, text)
+
+
+def serialize_xml(value: CertificateSource, parent: Element, tag: str) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> CertificateSource:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/certificate_transparency_logging_preference.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CertificateTransparencyLoggingPreference``."""
+
+from typing import Literal, TypeAlias, cast
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+CertificateTransparencyLoggingPreference: TypeAlias = Literal[
+    "enabled",
+    "disabled",
+]
+
+
+# --- restXml ser/de ---
+def to_xml_text(value: CertificateTransparencyLoggingPreference) -> str:
+    return value
+
+
+def from_xml_text(text: str) -> CertificateTransparencyLoggingPreference:
+    return cast(CertificateTransparencyLoggingPreference, text)
+
+
+def serialize_xml(
+    value: CertificateTransparencyLoggingPreference, parent: Element, tag: str
+) -> None:
+    SubElement(parent, tag).text = to_xml_text(value)
+
+
+def deserialize_xml(el: Element) -> CertificateTransparencyLoggingPreference:
+    return from_xml_text(el.text or "")

capo_cloudfront/types/cloud_front_origin_access_identity.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CloudFrontOriginAccessIdentity``."""
+
+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.cloud_front_origin_access_identity_config
+    import capo_cloudfront.types.string
+
+
+class CloudFrontOriginAccessIdentity(TypedDict, closed=True):
+    id: "capo_cloudfront.types.string.string"
+    """<p>The ID for the origin access identity, for example, <code>E74FTE3AJFJ256A</code>. </p>"""
+    s3_canonical_user_id: "capo_cloudfront.types.string.string"
+    """<p>The Amazon S3 canonical user ID for the origin access identity, used when giving the origin access identity read permission to an object in Amazon S3.</p>"""
+    cloud_front_origin_access_identity_config: NotRequired[
+        "capo_cloudfront.types.cloud_front_origin_access_identity_config.CloudFrontOriginAccessIdentityConfig"
+    ]
+    """<p>The current configuration information for the identity.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CloudFrontOriginAccessIdentity, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Id").text = str(value["id"])
+    SubElement(el, "S3CanonicalUserId").text = str(value["s3_canonical_user_id"])
+    if "cloud_front_origin_access_identity_config" in value:
+        import capo_cloudfront.types.cloud_front_origin_access_identity_config
+
+        capo_cloudfront.types.cloud_front_origin_access_identity_config.serialize_xml(
+            value["cloud_front_origin_access_identity_config"],
+            el,
+            "CloudFrontOriginAccessIdentityConfig",
+        )
+
+
+def deserialize_xml(el: Element) -> CloudFrontOriginAccessIdentity:
+    out: CloudFrontOriginAccessIdentity = {}  # type: ignore[typeddict-item]
+    child_id = el.find("Id")
+    if child_id is not None:
+        out["id"] = str(child_id.text or "")
+    else:
+        raise DeserializationError("CloudFrontOriginAccessIdentity.id required")
+    child_s3_canonical_user_id = el.find("S3CanonicalUserId")
+    if child_s3_canonical_user_id is not None:
+        out["s3_canonical_user_id"] = str(child_s3_canonical_user_id.text or "")
+    else:
+        raise DeserializationError(
+            "CloudFrontOriginAccessIdentity.s3_canonical_user_id required"
+        )
+    child_cloud_front_origin_access_identity_config = el.find(
+        "CloudFrontOriginAccessIdentityConfig"
+    )
+    if child_cloud_front_origin_access_identity_config is not None:
+        import capo_cloudfront.types.cloud_front_origin_access_identity_config
+
+        out["cloud_front_origin_access_identity_config"] = (
+            capo_cloudfront.types.cloud_front_origin_access_identity_config.deserialize_xml(
+                child_cloud_front_origin_access_identity_config
+            )
+        )
+    return out