capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/types/copy_distribution_request.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CopyDistributionRequest``."""
+
+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.string
+
+
+class CopyDistributionRequest(TypedDict, closed=True):
+    primary_distribution_id: "capo_cloudfront.types.string.string"
+    """<p>The identifier of the primary distribution whose configuration you are copying. To get a distribution ID, use <code>ListDistributions</code>.</p>"""
+    staging: NotRequired["capo_cloudfront.types.boolean.boolean"]
+    """<p>The type of distribution that your primary distribution will be copied to. The only valid value is <code>True</code>, indicating that you are copying to a staging distribution.</p>"""
+    if_match: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The version identifier of the primary distribution whose configuration you are copying. This is the <code>ETag</code> value returned in the response to <code>GetDistribution</code> and <code>GetDistributionConfig</code>.</p>"""
+    caller_reference: "capo_cloudfront.types.string.string"
+    """<p>A value that uniquely identifies a request to create a resource. This helps to prevent CloudFront from creating a duplicate resource if you accidentally resubmit an identical request.</p>"""
+    enabled: NotRequired["capo_cloudfront.types.boolean.boolean"]
+    """<p>A Boolean flag to specify the state of the staging distribution when it's created. When you set this value to <code>True</code>, the staging distribution is enabled. When you set this value to <code>False</code>, the staging distribution is disabled.</p> <p>If you omit this field, the default value is <code>True</code>.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CopyDistributionRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "CallerReference").text = str(value["caller_reference"])
+    if "enabled" in value:
+        SubElement(el, "Enabled").text = "true" if value["enabled"] else "false"
+
+
+def deserialize_xml(el: Element) -> CopyDistributionRequest:
+    out: CopyDistributionRequest = {}  # type: ignore[typeddict-item]
+    child_caller_reference = el.find("CallerReference")
+    if child_caller_reference is not None:
+        out["caller_reference"] = str(child_caller_reference.text or "")
+    else:
+        raise DeserializationError("CopyDistributionRequest.caller_reference required")
+    child_enabled = el.find("Enabled")
+    if child_enabled is not None:
+        out["enabled"] = (child_enabled.text or "").lower() == "true"
+    return out

capo_cloudfront/types/copy_distribution_result.py

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

capo_cloudfront/types/create_anycast_ip_list_request.py

@@ -0,0 +1,88 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateAnycastIpListRequest``."""
+
+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.anycast_ip_list_name
+    import capo_cloudfront.types.integer
+    import capo_cloudfront.types.ip_address_type
+    import capo_cloudfront.types.ipam_cidr_config_list
+    import capo_cloudfront.types.tags
+
+
+class CreateAnycastIpListRequest(TypedDict, closed=True):
+    name: "capo_cloudfront.types.anycast_ip_list_name.AnycastIpListName"
+    """<p>Name of the Anycast static IP list.</p>"""
+    ip_count: "capo_cloudfront.types.integer.integer"
+    """<p>The number of static IP addresses that are allocated to the Anycast static IP list. Valid values: 21 or 3.</p>"""
+    tags: NotRequired["capo_cloudfront.types.tags.Tags"]
+    ip_address_type: NotRequired["capo_cloudfront.types.ip_address_type.IpAddressType"]
+    """<p>The IP address type for the Anycast static IP list. You can specify one of the following options:</p> <ul> <li> <p> <code>ipv4</code> only</p> </li> <li> <p> <code>ipv6</code> only </p> </li> <li> <p> <code>dualstack</code> - Allocate a list of both IPv4 and IPv6 addresses</p> </li> </ul>"""
+    ipam_cidr_configs: NotRequired[
+        "capo_cloudfront.types.ipam_cidr_config_list.IpamCidrConfigList"
+    ]
+    """<p> A list of IPAM CIDR configurations that specify the IP address ranges and IPAM pool settings for creating the Anycast static IP list. </p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateAnycastIpListRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Name").text = str(value["name"])
+    SubElement(el, "IpCount").text = str(value["ip_count"])
+    if "tags" in value:
+        import capo_cloudfront.types.tags
+
+        capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+    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 "ipam_cidr_configs" in value:
+        import capo_cloudfront.types.ipam_cidr_config_list
+
+        capo_cloudfront.types.ipam_cidr_config_list.serialize_xml(
+            value["ipam_cidr_configs"], el, "IpamCidrConfigs"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateAnycastIpListRequest:
+    out: CreateAnycastIpListRequest = {}  # 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("CreateAnycastIpListRequest.name required")
+    child_ip_count = el.find("IpCount")
+    if child_ip_count is not None:
+        out["ip_count"] = int(child_ip_count.text or "")
+    else:
+        raise DeserializationError("CreateAnycastIpListRequest.ip_count 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)
+    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_ipam_cidr_configs = el.find("IpamCidrConfigs")
+    if child_ipam_cidr_configs is not None:
+        import capo_cloudfront.types.ipam_cidr_config_list
+
+        out["ipam_cidr_configs"] = (
+            capo_cloudfront.types.ipam_cidr_config_list.deserialize_xml(
+                child_ipam_cidr_configs
+            )
+        )
+    return out

capo_cloudfront/types/create_anycast_ip_list_result.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateAnycastIpListResult``."""
+
+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.anycast_ip_list
+    import capo_cloudfront.types.string
+
+
+class CreateAnycastIpListResult(TypedDict, closed=True):
+    anycast_ip_list: NotRequired["capo_cloudfront.types.anycast_ip_list.AnycastIpList"]
+    """<p>A response structure that includes the version identifier (ETag) and the created <a>AnycastIpList</a> structure.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The version identifier for the current version of the Anycast static IP list.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateAnycastIpListResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "anycast_ip_list" in value:
+        import capo_cloudfront.types.anycast_ip_list
+
+        capo_cloudfront.types.anycast_ip_list.serialize_xml(
+            value["anycast_ip_list"], el, "AnycastIpList"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateAnycastIpListResult:
+    out: CreateAnycastIpListResult = {}  # type: ignore[typeddict-item]
+    child_anycast_ip_list = el.find("AnycastIpList")
+    if child_anycast_ip_list is not None:
+        import capo_cloudfront.types.anycast_ip_list
+
+        out["anycast_ip_list"] = capo_cloudfront.types.anycast_ip_list.deserialize_xml(
+            child_anycast_ip_list
+        )
+    return out

capo_cloudfront/types/create_cache_policy_request.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateCachePolicyRequest``."""
+
+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_config
+
+
+class CreateCachePolicyRequest(TypedDict, closed=True):
+    cache_policy_config: "capo_cloudfront.types.cache_policy_config.CachePolicyConfig"
+    """<p>A cache policy configuration.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateCachePolicyRequest, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    import capo_cloudfront.types.cache_policy_config
+
+    capo_cloudfront.types.cache_policy_config.serialize_xml(
+        value["cache_policy_config"], el, "CachePolicyConfig"
+    )
+
+
+def deserialize_xml(el: Element) -> CreateCachePolicyRequest:
+    out: CreateCachePolicyRequest = {}  # type: ignore[typeddict-item]
+    child_cache_policy_config = el.find("CachePolicyConfig")
+    if child_cache_policy_config is not None:
+        import capo_cloudfront.types.cache_policy_config
+
+        out["cache_policy_config"] = (
+            capo_cloudfront.types.cache_policy_config.deserialize_xml(
+                child_cache_policy_config
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateCachePolicyRequest.cache_policy_config required"
+        )
+    return out

capo_cloudfront/types/create_cache_policy_result.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateCachePolicyResult``."""
+
+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.cache_policy
+    import capo_cloudfront.types.string
+
+
+class CreateCachePolicyResult(TypedDict, closed=True):
+    cache_policy: NotRequired["capo_cloudfront.types.cache_policy.CachePolicy"]
+    """<p>A cache policy.</p>"""
+    location: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The fully qualified URI of the cache policy just created.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The current version of the cache policy.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: CreateCachePolicyResult, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    if "cache_policy" in value:
+        import capo_cloudfront.types.cache_policy
+
+        capo_cloudfront.types.cache_policy.serialize_xml(
+            value["cache_policy"], el, "CachePolicy"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateCachePolicyResult:
+    out: CreateCachePolicyResult = {}  # type: ignore[typeddict-item]
+    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
+        )
+    return out

capo_cloudfront/types/create_cloud_front_origin_access_identity_request.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateCloudFrontOriginAccessIdentityRequest``."""
+
+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.cloud_front_origin_access_identity_config
+
+
+class CreateCloudFrontOriginAccessIdentityRequest(TypedDict, closed=True):
+    cloud_front_origin_access_identity_config: "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: CreateCloudFrontOriginAccessIdentityRequest, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    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) -> CreateCloudFrontOriginAccessIdentityRequest:
+    out: CreateCloudFrontOriginAccessIdentityRequest = {}  # type: ignore[typeddict-item]
+    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
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateCloudFrontOriginAccessIdentityRequest.cloud_front_origin_access_identity_config required"
+        )
+    return out

capo_cloudfront/types/create_cloud_front_origin_access_identity_result.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateCloudFrontOriginAccessIdentityResult``."""
+
+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.cloud_front_origin_access_identity
+    import capo_cloudfront.types.string
+
+
+class CreateCloudFrontOriginAccessIdentityResult(TypedDict, closed=True):
+    cloud_front_origin_access_identity: NotRequired[
+        "capo_cloudfront.types.cloud_front_origin_access_identity.CloudFrontOriginAccessIdentity"
+    ]
+    """<p>The origin access identity's information.</p>"""
+    location: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The fully qualified URI of the new origin access identity just created.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The current version of the origin access identity created.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CreateCloudFrontOriginAccessIdentityResult, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    if "cloud_front_origin_access_identity" in value:
+        import capo_cloudfront.types.cloud_front_origin_access_identity
+
+        capo_cloudfront.types.cloud_front_origin_access_identity.serialize_xml(
+            value["cloud_front_origin_access_identity"],
+            el,
+            "CloudFrontOriginAccessIdentity",
+        )
+
+
+def deserialize_xml(el: Element) -> CreateCloudFrontOriginAccessIdentityResult:
+    out: CreateCloudFrontOriginAccessIdentityResult = {}  # type: ignore[typeddict-item]
+    child_cloud_front_origin_access_identity = el.find("CloudFrontOriginAccessIdentity")
+    if child_cloud_front_origin_access_identity is not None:
+        import capo_cloudfront.types.cloud_front_origin_access_identity
+
+        out["cloud_front_origin_access_identity"] = (
+            capo_cloudfront.types.cloud_front_origin_access_identity.deserialize_xml(
+                child_cloud_front_origin_access_identity
+            )
+        )
+    return out

capo_cloudfront/types/create_connection_function_request.py

@@ -0,0 +1,86 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateConnectionFunctionRequest``."""
+
+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_blob
+    import capo_cloudfront.types.function_config
+    import capo_cloudfront.types.function_name
+    import capo_cloudfront.types.tags
+
+
+class CreateConnectionFunctionRequest(TypedDict, closed=True):
+    name: "capo_cloudfront.types.function_name.FunctionName"
+    """<p>A name for the connection function.</p>"""
+    connection_function_config: "capo_cloudfront.types.function_config.FunctionConfig"
+    connection_function_code: "capo_cloudfront.types.function_blob.FunctionBlob"
+    """<p>The code for the connection function.</p>"""
+    tags: NotRequired["capo_cloudfront.types.tags.Tags"]
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CreateConnectionFunctionRequest, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Name").text = str(value["name"])
+    import capo_cloudfront.types.function_config
+
+    capo_cloudfront.types.function_config.serialize_xml(
+        value["connection_function_config"], el, "ConnectionFunctionConfig"
+    )
+    import capo_cloudfront.types.function_blob
+
+    capo_cloudfront.types.function_blob.serialize_xml(
+        value["connection_function_code"], el, "ConnectionFunctionCode"
+    )
+    if "tags" in value:
+        import capo_cloudfront.types.tags
+
+        capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+
+
+def deserialize_xml(el: Element) -> CreateConnectionFunctionRequest:
+    out: CreateConnectionFunctionRequest = {}  # 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("CreateConnectionFunctionRequest.name required")
+    child_connection_function_config = el.find("ConnectionFunctionConfig")
+    if child_connection_function_config is not None:
+        import capo_cloudfront.types.function_config
+
+        out["connection_function_config"] = (
+            capo_cloudfront.types.function_config.deserialize_xml(
+                child_connection_function_config
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateConnectionFunctionRequest.connection_function_config required"
+        )
+    child_connection_function_code = el.find("ConnectionFunctionCode")
+    if child_connection_function_code is not None:
+        import capo_cloudfront.types.function_blob
+
+        out["connection_function_code"] = (
+            capo_cloudfront.types.function_blob.deserialize_xml(
+                child_connection_function_code
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateConnectionFunctionRequest.connection_function_code 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_connection_function_result.py

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

capo_cloudfront/types/create_connection_group_request.py

@@ -0,0 +1,69 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateConnectionGroupRequest``."""
+
+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.string
+    import capo_cloudfront.types.tags
+
+
+class CreateConnectionGroupRequest(TypedDict, closed=True):
+    name: "capo_cloudfront.types.string.string"
+    """<p>The name of the connection group. Enter a friendly identifier that is unique within your Amazon Web Services account. This name can't be updated after you create the connection group.</p>"""
+    ipv6_enabled: NotRequired["capo_cloudfront.types.boolean.boolean"]
+    r"""<p>Enable IPv6 for the connection group. The default is <code>true</code>. For more information, see <a href=\"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-values-specify.html#DownloadDistValuesEnableIPv6\">Enable IPv6</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>"""
+    tags: NotRequired["capo_cloudfront.types.tags.Tags"]
+    anycast_ip_list_id: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The ID of the Anycast static IP list.</p>"""
+    enabled: NotRequired["capo_cloudfront.types.boolean.boolean"]
+    """<p>Enable the connection group.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CreateConnectionGroupRequest, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Name").text = str(value["name"])
+    if "ipv6_enabled" in value:
+        SubElement(el, "Ipv6Enabled").text = (
+            "true" if value["ipv6_enabled"] else "false"
+        )
+    if "tags" in value:
+        import capo_cloudfront.types.tags
+
+        capo_cloudfront.types.tags.serialize_xml(value["tags"], el, "Tags")
+    if "anycast_ip_list_id" in value:
+        SubElement(el, "AnycastIpListId").text = str(value["anycast_ip_list_id"])
+    if "enabled" in value:
+        SubElement(el, "Enabled").text = "true" if value["enabled"] else "false"
+
+
+def deserialize_xml(el: Element) -> CreateConnectionGroupRequest:
+    out: CreateConnectionGroupRequest = {}  # 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("CreateConnectionGroupRequest.name required")
+    child_ipv6_enabled = el.find("Ipv6Enabled")
+    if child_ipv6_enabled is not None:
+        out["ipv6_enabled"] = (child_ipv6_enabled.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)
+    child_anycast_ip_list_id = el.find("AnycastIpListId")
+    if child_anycast_ip_list_id is not None:
+        out["anycast_ip_list_id"] = str(child_anycast_ip_list_id.text or "")
+    child_enabled = el.find("Enabled")
+    if child_enabled is not None:
+        out["enabled"] = (child_enabled.text or "").lower() == "true"
+    return out

capo_cloudfront/types/create_connection_group_result.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateConnectionGroupResult``."""
+
+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_group
+    import capo_cloudfront.types.string
+
+
+class CreateConnectionGroupResult(TypedDict, closed=True):
+    connection_group: NotRequired[
+        "capo_cloudfront.types.connection_group.ConnectionGroup"
+    ]
+    """<p>The connection group that you created.</p>"""
+    e_tag: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>The current version of the connection group.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: CreateConnectionGroupResult, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    if "connection_group" in value:
+        import capo_cloudfront.types.connection_group
+
+        capo_cloudfront.types.connection_group.serialize_xml(
+            value["connection_group"], el, "ConnectionGroup"
+        )
+
+
+def deserialize_xml(el: Element) -> CreateConnectionGroupResult:
+    out: CreateConnectionGroupResult = {}  # type: ignore[typeddict-item]
+    child_connection_group = el.find("ConnectionGroup")
+    if child_connection_group is not None:
+        import capo_cloudfront.types.connection_group
+
+        out["connection_group"] = (
+            capo_cloudfront.types.connection_group.deserialize_xml(
+                child_connection_group
+            )
+        )
+    return out