capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/types/create_trust_store_request.py

@@ -0,0 +1,82 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateTrustStoreRequest``."""
+
+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.boolean
+    import capo_cloudfront.types.ca_certificates_bundle_source
+    import capo_cloudfront.types.string
+    import capo_cloudfront.types.tags
+
+
+class CreateTrustStoreRequest(TypedDict, closed=True):
+    name: "capo_cloudfront.types.string.string"
+    """<p>A name for the trust store.</p>"""
+    ca_certificates_bundle_source: (
+        "capo_cloudfront.types.ca_certificates_bundle_source.CaCertificatesBundleSource"
+    )
+    """<p>The CA certificates bundle source for the trust store.</p>"""
+    use_client_certificate_ocsp_endpoint: NotRequired[
+        "capo_cloudfront.types.boolean.boolean"
+    ]
+    """<p>A Boolean that determines whether to use the CA certificate's OCSP endpoint to check certificate revocation status.</p>"""
+    tags: NotRequired["capo_cloudfront.types.tags.Tags"]
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateTrustStoreRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Name").text = str(value["name"])
+    import capo_cloudfront.types.ca_certificates_bundle_source
+
+    capo_cloudfront.types.ca_certificates_bundle_source.serialize_xml(
+        value["ca_certificates_bundle_source"], el, "CaCertificatesBundleSource"
+    )
+    if "use_client_certificate_ocsp_endpoint" in value:
+        SubElement(el, "UseClientCertificateOCSPEndpoint").text = (
+            "true" if value["use_client_certificate_ocsp_endpoint"] else "false"
+        )
+    if "tags" in value:
+        import capo_cloudfront.types.tags
+
+        capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+
+
+def deserialize_xml(el: Element) -> CreateTrustStoreRequest:
+    out: CreateTrustStoreRequest = {}  # type: ignore[typeddict-item]
+    child_name = el.find("Name")
+    if child_name is not None:
+        out["name"] = str(child_name.text or "")
+    else:
+        raise DeserializationError("CreateTrustStoreRequest.name required")
+    child_ca_certificates_bundle_source = el.find("CaCertificatesBundleSource")
+    if child_ca_certificates_bundle_source is not None:
+        import capo_cloudfront.types.ca_certificates_bundle_source
+
+        out["ca_certificates_bundle_source"] = (
+            capo_cloudfront.types.ca_certificates_bundle_source.deserialize_xml(
+                child_ca_certificates_bundle_source
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateTrustStoreRequest.ca_certificates_bundle_source required"
+        )
+    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"
+    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)
+    return out

capo_cloudfront/types/create_trust_store_result.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateTrustStoreResult``."""
+
+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.string
+    import capo_cloudfront.types.trust_store
+
+
+class CreateTrustStoreResult(TypedDict, closed=True):
+    trust_store: NotRequired["capo_cloudfront.types.trust_store.TrustStore"]
+    """<p>The trust store.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The version identifier for the current version of the trust store.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateTrustStoreResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "trust_store" in value:
+        import capo_cloudfront.types.trust_store
+
+        capo_cloudfront.types.trust_store.serialize_xml(
+            value["trust_store"], el, "TrustStore"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateTrustStoreResult:
+    out: CreateTrustStoreResult = {}  # type: ignore[typeddict-item]
+    child_trust_store = el.find("TrustStore")
+    if child_trust_store is not None:
+        import capo_cloudfront.types.trust_store
+
+        out["trust_store"] = capo_cloudfront.types.trust_store.deserialize_xml(
+            child_trust_store
+        )
+    return out

capo_cloudfront/types/create_vpc_origin_request.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateVpcOriginRequest``."""
+
+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.tags
+    import capo_cloudfront.types.vpc_origin_endpoint_config
+
+
+class CreateVpcOriginRequest(TypedDict, closed=True):
+    vpc_origin_endpoint_config: (
+        "capo_cloudfront.types.vpc_origin_endpoint_config.VpcOriginEndpointConfig"
+    )
+    """<p>The VPC origin endpoint configuration.</p>"""
+    tags: NotRequired["capo_cloudfront.types.tags.Tags"]
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateVpcOriginRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.vpc_origin_endpoint_config
+
+    capo_cloudfront.types.vpc_origin_endpoint_config.serialize_xml(
+        value["vpc_origin_endpoint_config"], el, "VpcOriginEndpointConfig"
+    )
+    if "tags" in value:
+        import capo_cloudfront.types.tags
+
+        capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+
+
+def deserialize_xml(el: Element) -> CreateVpcOriginRequest:
+    out: CreateVpcOriginRequest = {}  # type: ignore[typeddict-item]
+    child_vpc_origin_endpoint_config = el.find("VpcOriginEndpointConfig")
+    if child_vpc_origin_endpoint_config is not None:
+        import capo_cloudfront.types.vpc_origin_endpoint_config
+
+        out["vpc_origin_endpoint_config"] = (
+            capo_cloudfront.types.vpc_origin_endpoint_config.deserialize_xml(
+                child_vpc_origin_endpoint_config
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateVpcOriginRequest.vpc_origin_endpoint_config required"
+        )
+    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)
+    return out

capo_cloudfront/types/create_vpc_origin_result.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateVpcOriginResult``."""
+
+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.string
+    import capo_cloudfront.types.vpc_origin
+
+
+class CreateVpcOriginResult(TypedDict, closed=True):
+    vpc_origin: NotRequired["capo_cloudfront.types.vpc_origin.VpcOrigin"]
+    """<p>The VPC origin.</p>"""
+    location: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The VPC origin location.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The VPC origin ETag.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateVpcOriginResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "vpc_origin" in value:
+        import capo_cloudfront.types.vpc_origin
+
+        capo_cloudfront.types.vpc_origin.serialize_xml(
+            value["vpc_origin"], el, "VpcOrigin"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateVpcOriginResult:
+    out: CreateVpcOriginResult = {}  # type: ignore[typeddict-item]
+    child_vpc_origin = el.find("VpcOrigin")
+    if child_vpc_origin is not None:
+        import capo_cloudfront.types.vpc_origin
+
+        out["vpc_origin"] = capo_cloudfront.types.vpc_origin.deserialize_xml(
+            child_vpc_origin
+        )
+    return out

capo_cloudfront/types/custom_error_response.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CustomErrorResponse``."""
+
+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.integer
+    import capo_cloudfront.types.long
+    import capo_cloudfront.types.string
+
+
+class CustomErrorResponse(TypedDict, closed=True):
+    error_code: "capo_cloudfront.types.integer.integer"
+    """<p>The HTTP status code for which you want to specify a custom error page and/or a caching duration.</p>"""
+    response_page_path: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The path to the custom error page that you want CloudFront to return to a viewer when your origin returns the HTTP status code specified by <code>ErrorCode</code>, for example, <code>/4xx-errors/403-forbidden.html</code>. If you want to store your objects and your custom error pages in different locations, your distribution must include a cache behavior for which the following is true:</p> <ul> <li> <p>The value of <code>PathPattern</code> matches the path to your custom error messages. For example, suppose you saved custom error pages for 4xx errors in an Amazon S3 bucket in a directory named <code>/4xx-errors</code>. Your distribution must include a cache behavior for which the path pattern routes requests for your custom error pages to that location, for example, <code>/4xx-errors/*</code>.</p> </li> <li> <p>The value of <code>TargetOriginId</code> specifies the value of the <code>ID</code> element for the origin that contains your custom error pages.</p> </li> </ul> <p>If you specify a value for <code>ResponsePagePath</code>, you must also specify a value for <code>ResponseCode</code>.</p> <p>We recommend that you store custom error pages in an Amazon S3 bucket. If you store custom error pages on an HTTP server and the server starts to return 5xx errors, CloudFront can't get the files that you want to return to viewers because the origin server is unavailable.</p>"""
+    response_code: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The HTTP status code that you want CloudFront to return to the viewer along with the custom error page. There are a variety of reasons that you might want CloudFront to return a status code different from the status code that your origin returned to CloudFront, for example:</p> <ul> <li> <p>Some Internet devices (some firewalls and corporate proxies, for example) intercept HTTP 4xx and 5xx and prevent the response from being returned to the viewer. If you substitute <code>200</code>, the response typically won't be intercepted.</p> </li> <li> <p>If you don't care about distinguishing among different client errors or server errors, you can specify <code>400</code> or <code>500</code> as the <code>ResponseCode</code> for all 4xx or 5xx errors.</p> </li> <li> <p>You might want to return a <code>200</code> status code (OK) and static website so your customers don't know that your website is down.</p> </li> </ul> <p>If you specify a value for <code>ResponseCode</code>, you must also specify a value for <code>ResponsePagePath</code>.</p>"""
+    error_caching_min_ttl: NotRequired["capo_cloudfront.types.long.long"]
+    r"""<p>The minimum amount of time, in seconds, that you want CloudFront to cache the HTTP status code specified in <code>ErrorCode</code>. When this time period has elapsed, CloudFront queries your origin to see whether the problem that caused the error has been resolved and the requested object is now available.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/custom-error-pages.html\">Customizing Error Responses</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CustomErrorResponse, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "ErrorCode").text = str(value["error_code"])
+    if "response_page_path" in value:
+        SubElement(el, "ResponsePagePath").text = str(value["response_page_path"])
+    if "response_code" in value:
+        SubElement(el, "ResponseCode").text = str(value["response_code"])
+    if "error_caching_min_ttl" in value:
+        SubElement(el, "ErrorCachingMinTTL").text = str(value["error_caching_min_ttl"])
+
+
+def deserialize_xml(el: Element) -> CustomErrorResponse:
+    out: CustomErrorResponse = {}  # type: ignore[typeddict-item]
+    child_error_code = el.find("ErrorCode")
+    if child_error_code is not None:
+        out["error_code"] = int(child_error_code.text or "")
+    else:
+        raise DeserializationError("CustomErrorResponse.error_code required")
+    child_response_page_path = el.find("ResponsePagePath")
+    if child_response_page_path is not None:
+        out["response_page_path"] = str(child_response_page_path.text or "")
+    child_response_code = el.find("ResponseCode")
+    if child_response_code is not None:
+        out["response_code"] = str(child_response_code.text or "")
+    child_error_caching_min_ttl = el.find("ErrorCachingMinTTL")
+    if child_error_caching_min_ttl is not None:
+        out["error_caching_min_ttl"] = int(child_error_caching_min_ttl.text or "")
+    return out

capo_cloudfront/types/custom_error_response_list.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CustomErrorResponseList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from capo_cloudfront._protocol.xml import Element, SubElement
+
+if TYPE_CHECKING:
+    import capo_cloudfront.types.custom_error_response
+
+CustomErrorResponseList: TypeAlias = list[
+    "capo_cloudfront.types.custom_error_response.CustomErrorResponse"
+]
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CustomErrorResponseList, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    for item in value:
+        import capo_cloudfront.types.custom_error_response
+
+        capo_cloudfront.types.custom_error_response.serialize_xml(
+            item, el, "CustomErrorResponse"
+        )
+
+
+def deserialize_xml(el: Element) -> CustomErrorResponseList:
+    import capo_cloudfront.types.custom_error_response
+
+    out: CustomErrorResponseList = []
+    for child in el.findall("CustomErrorResponse"):
+        out.append(capo_cloudfront.types.custom_error_response.deserialize_xml(child))
+    return out
+
+
+def serialize_xml_flat(
+    value: CustomErrorResponseList, 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.custom_error_response
+
+        capo_cloudfront.types.custom_error_response.serialize_xml(item, parent, tag)
+
+
+def deserialize_xml_flat(parent: Element, tag: str) -> CustomErrorResponseList:
+    import capo_cloudfront.types.custom_error_response
+
+    out: CustomErrorResponseList = []
+    for child in parent.findall(tag):
+        out.append(capo_cloudfront.types.custom_error_response.deserialize_xml(child))
+    return out

capo_cloudfront/types/custom_error_responses.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CustomErrorResponses``."""
+
+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.custom_error_response_list
+    import capo_cloudfront.types.integer
+
+
+class CustomErrorResponses(TypedDict, closed=True):
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>The number of HTTP status codes for which you want to specify a custom error page and/or a caching duration. If <code>Quantity</code> is <code>0</code>, you can omit <code>Items</code>.</p>"""
+    items: NotRequired[
+        "capo_cloudfront.types.custom_error_response_list.CustomErrorResponseList"
+    ]
+    """<p>A complex type that contains a <code>CustomErrorResponse</code> element for each HTTP status code for which you want to specify a custom error page and/or a caching duration. </p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CustomErrorResponses, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Quantity").text = str(value["quantity"])
+    if "items" in value:
+        import capo_cloudfront.types.custom_error_response_list
+
+        capo_cloudfront.types.custom_error_response_list.serialize_xml(
+            value["items"], el, "Items"
+        )
+
+
+def deserialize_xml(el: Element) -> CustomErrorResponses:
+    out: CustomErrorResponses = {}  # 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("CustomErrorResponses.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.custom_error_response_list
+
+        out["items"] = capo_cloudfront.types.custom_error_response_list.deserialize_xml(
+            child_items
+        )
+    return out

capo_cloudfront/types/custom_headers.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CustomHeaders``."""
+
+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.integer
+    import capo_cloudfront.types.origin_custom_headers_list
+
+
+class CustomHeaders(TypedDict, closed=True):
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>The number of custom headers, if any, for this distribution.</p>"""
+    items: NotRequired[
+        "capo_cloudfront.types.origin_custom_headers_list.OriginCustomHeadersList"
+    ]
+    """<p> <b>Optional</b>: A list that contains one <code>OriginCustomHeader</code> element for each custom header that you want CloudFront to forward to the origin. If Quantity is <code>0</code>, omit <code>Items</code>.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CustomHeaders, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Quantity").text = str(value["quantity"])
+    if "items" in value:
+        import capo_cloudfront.types.origin_custom_headers_list
+
+        capo_cloudfront.types.origin_custom_headers_list.serialize_xml(
+            value["items"], el, "Items"
+        )
+
+
+def deserialize_xml(el: Element) -> CustomHeaders:
+    out: CustomHeaders = {}  # 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("CustomHeaders.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.origin_custom_headers_list
+
+        out["items"] = capo_cloudfront.types.origin_custom_headers_list.deserialize_xml(
+            child_items
+        )
+    return out

capo_cloudfront/types/custom_origin_config.py

@@ -0,0 +1,133 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CustomOriginConfig``."""
+
+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.integer
+    import capo_cloudfront.types.ip_address_type
+    import capo_cloudfront.types.origin_mtls_config
+    import capo_cloudfront.types.origin_protocol_policy
+    import capo_cloudfront.types.origin_ssl_protocols
+
+
+class CustomOriginConfig(TypedDict, closed=True):
+    http_port: "capo_cloudfront.types.integer.integer"
+    """<p>The HTTP port that CloudFront uses to connect to the origin. Specify the HTTP port that the origin listens on.</p>"""
+    https_port: "capo_cloudfront.types.integer.integer"
+    """<p>The HTTPS port that CloudFront uses to connect to the origin. Specify the HTTPS port that the origin listens on.</p>"""
+    origin_protocol_policy: (
+        "capo_cloudfront.types.origin_protocol_policy.OriginProtocolPolicy"
+    )
+    """<p>Specifies the protocol (HTTP or HTTPS) that CloudFront uses to connect to the origin. Valid values are:</p> <ul> <li> <p> <code>http-only</code> – CloudFront always uses HTTP to connect to the origin.</p> </li> <li> <p> <code>match-viewer</code> – CloudFront connects to the origin using the same protocol that the viewer used to connect to CloudFront.</p> </li> <li> <p> <code>https-only</code> – CloudFront always uses HTTPS to connect to the origin.</p> </li> </ul>"""
+    origin_ssl_protocols: NotRequired[
+        "capo_cloudfront.types.origin_ssl_protocols.OriginSslProtocols"
+    ]
+    r"""<p>Specifies the minimum SSL/TLS protocol that CloudFront uses when connecting to your origin over HTTPS. Valid values include <code>SSLv3</code>, <code>TLSv1</code>, <code>TLSv1.1</code>, and <code>TLSv1.2</code>.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginSSLProtocols\">Minimum Origin SSL Protocol</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+    origin_read_timeout: NotRequired["capo_cloudfront.types.integer.integer"]
+    r"""<p>Specifies how long, in seconds, CloudFront waits for a response from the origin. This is also known as the <i>origin response timeout</i>. The minimum timeout is 1 second, the maximum is 120 seconds, and the default (if you don't specify otherwise) is 30 seconds.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginResponseTimeout\">Response timeout</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+    origin_keepalive_timeout: NotRequired["capo_cloudfront.types.integer.integer"]
+    r"""<p>Specifies how long, in seconds, CloudFront persists its connection to the origin. The minimum timeout is 1 second, the maximum is 120 seconds, and the default (if you don't specify otherwise) is 5 seconds.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginKeepaliveTimeout\">Keep-alive timeout (custom origins only)</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+    ip_address_type: NotRequired["capo_cloudfront.types.ip_address_type.IpAddressType"]
+    """<p>Specifies which IP protocol CloudFront uses when connecting to your origin. If your origin uses both IPv4 and IPv6 protocols, you can choose <code>dualstack</code> to help optimize reliability.</p>"""
+    origin_mtls_config: NotRequired[
+        "capo_cloudfront.types.origin_mtls_config.OriginMtlsConfig"
+    ]
+    """<p>Configures mutual TLS authentication between CloudFront and your origin server.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CustomOriginConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "HTTPPort").text = str(value["http_port"])
+    SubElement(el, "HTTPSPort").text = str(value["https_port"])
+    import capo_cloudfront.types.origin_protocol_policy
+
+    capo_cloudfront.types.origin_protocol_policy.serialize_xml(
+        value["origin_protocol_policy"], el, "OriginProtocolPolicy"
+    )
+    if "origin_ssl_protocols" in value:
+        import capo_cloudfront.types.origin_ssl_protocols
+
+        capo_cloudfront.types.origin_ssl_protocols.serialize_xml(
+            value["origin_ssl_protocols"], el, "OriginSslProtocols"
+        )
+    if "origin_read_timeout" in value:
+        SubElement(el, "OriginReadTimeout").text = str(value["origin_read_timeout"])
+    if "origin_keepalive_timeout" in value:
+        SubElement(el, "OriginKeepaliveTimeout").text = str(
+            value["origin_keepalive_timeout"]
+        )
+    if "ip_address_type" in value:
+        import capo_cloudfront.types.ip_address_type
+
+        capo_cloudfront.types.ip_address_type.serialize_xml(
+            value["ip_address_type"], el, "IpAddressType"
+        )
+    if "origin_mtls_config" in value:
+        import capo_cloudfront.types.origin_mtls_config
+
+        capo_cloudfront.types.origin_mtls_config.serialize_xml(
+            value["origin_mtls_config"], el, "OriginMtlsConfig"
+        )
+
+
+def deserialize_xml(el: Element) -> CustomOriginConfig:
+    out: CustomOriginConfig = {}  # type: ignore[typeddict-item]
+    child_http_port = el.find("HTTPPort")
+    if child_http_port is not None:
+        out["http_port"] = int(child_http_port.text or "")
+    else:
+        raise DeserializationError("CustomOriginConfig.http_port required")
+    child_https_port = el.find("HTTPSPort")
+    if child_https_port is not None:
+        out["https_port"] = int(child_https_port.text or "")
+    else:
+        raise DeserializationError("CustomOriginConfig.https_port required")
+    child_origin_protocol_policy = el.find("OriginProtocolPolicy")
+    if child_origin_protocol_policy is not None:
+        import capo_cloudfront.types.origin_protocol_policy
+
+        out["origin_protocol_policy"] = (
+            capo_cloudfront.types.origin_protocol_policy.deserialize_xml(
+                child_origin_protocol_policy
+            )
+        )
+    else:
+        raise DeserializationError("CustomOriginConfig.origin_protocol_policy required")
+    child_origin_ssl_protocols = el.find("OriginSslProtocols")
+    if child_origin_ssl_protocols is not None:
+        import capo_cloudfront.types.origin_ssl_protocols
+
+        out["origin_ssl_protocols"] = (
+            capo_cloudfront.types.origin_ssl_protocols.deserialize_xml(
+                child_origin_ssl_protocols
+            )
+        )
+    child_origin_read_timeout = el.find("OriginReadTimeout")
+    if child_origin_read_timeout is not None:
+        out["origin_read_timeout"] = int(child_origin_read_timeout.text or "")
+    child_origin_keepalive_timeout = el.find("OriginKeepaliveTimeout")
+    if child_origin_keepalive_timeout is not None:
+        out["origin_keepalive_timeout"] = int(child_origin_keepalive_timeout.text or "")
+    child_ip_address_type = el.find("IpAddressType")
+    if child_ip_address_type is not None:
+        import capo_cloudfront.types.ip_address_type
+
+        out["ip_address_type"] = capo_cloudfront.types.ip_address_type.deserialize_xml(
+            child_ip_address_type
+        )
+    child_origin_mtls_config = el.find("OriginMtlsConfig")
+    if child_origin_mtls_config is not None:
+        import capo_cloudfront.types.origin_mtls_config
+
+        out["origin_mtls_config"] = (
+            capo_cloudfront.types.origin_mtls_config.deserialize_xml(
+                child_origin_mtls_config
+            )
+        )
+    return out

capo_cloudfront/types/customization_action_type.py

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