capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/types/encryption_entities.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#EncryptionEntities``."""
+
+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.encryption_entity_list
+    import capo_cloudfront.types.integer
+
+
+class EncryptionEntities(TypedDict, closed=True):
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>Number of field pattern items in a field-level encryption content type-profile mapping.</p>"""
+    items: NotRequired[
+        "capo_cloudfront.types.encryption_entity_list.EncryptionEntityList"
+    ]
+    """<p>An array of field patterns in a field-level encryption content type-profile mapping. </p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: EncryptionEntities, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Quantity").text = str(value["quantity"])
+    if "items" in value:
+        import capo_cloudfront.types.encryption_entity_list
+
+        capo_cloudfront.types.encryption_entity_list.serialize_xml(
+            value["items"], el, "Items"
+        )
+
+
+def deserialize_xml(el: Element) -> EncryptionEntities:
+    out: EncryptionEntities = {}  # 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("EncryptionEntities.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.encryption_entity_list
+
+        out["items"] = capo_cloudfront.types.encryption_entity_list.deserialize_xml(
+            child_items
+        )
+    return out

capo_cloudfront/types/encryption_entity.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#EncryptionEntity``."""
+
+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.field_patterns
+    import capo_cloudfront.types.string
+
+
+class EncryptionEntity(TypedDict, closed=True):
+    public_key_id: "capo_cloudfront.types.string.string"
+    """<p>The public key associated with a set of field-level encryption patterns, to be used when encrypting the fields that match the patterns.</p>"""
+    provider_id: "capo_cloudfront.types.string.string"
+    """<p>The provider associated with the public key being used for encryption. This value must also be provided with the private key for applications to be able to decrypt data.</p>"""
+    field_patterns: "capo_cloudfront.types.field_patterns.FieldPatterns"
+    """<p>Field patterns in a field-level encryption content type profile specify the fields that you want to be encrypted. You can provide the full field name, or any beginning characters followed by a wildcard (*). You can't overlap field patterns. For example, you can't have both ABC* and AB*. Note that field patterns are case-sensitive.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: EncryptionEntity, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "PublicKeyId").text = str(value["public_key_id"])
+    SubElement(el, "ProviderId").text = str(value["provider_id"])
+    import capo_cloudfront.types.field_patterns
+
+    capo_cloudfront.types.field_patterns.serialize_xml(
+        value["field_patterns"], el, "FieldPatterns"
+    )
+
+
+def deserialize_xml(el: Element) -> EncryptionEntity:
+    out: EncryptionEntity = {}  # type: ignore[typeddict-item]
+    child_public_key_id = el.find("PublicKeyId")
+    if child_public_key_id is not None:
+        out["public_key_id"] = str(child_public_key_id.text or "")
+    else:
+        raise DeserializationError("EncryptionEntity.public_key_id required")
+    child_provider_id = el.find("ProviderId")
+    if child_provider_id is not None:
+        out["provider_id"] = str(child_provider_id.text or "")
+    else:
+        raise DeserializationError("EncryptionEntity.provider_id required")
+    child_field_patterns = el.find("FieldPatterns")
+    if child_field_patterns is not None:
+        import capo_cloudfront.types.field_patterns
+
+        out["field_patterns"] = capo_cloudfront.types.field_patterns.deserialize_xml(
+            child_field_patterns
+        )
+    else:
+        raise DeserializationError("EncryptionEntity.field_patterns required")
+    return out

capo_cloudfront/types/encryption_entity_list.py

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

capo_cloudfront/types/end_point.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#EndPoint``."""
+
+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.kinesis_stream_config
+    import capo_cloudfront.types.string
+
+
+class EndPoint(TypedDict, closed=True):
+    stream_type: "capo_cloudfront.types.string.string"
+    """<p>The type of data stream where you are sending real-time log data. The only valid value is <code>Kinesis</code>.</p>"""
+    kinesis_stream_config: NotRequired[
+        "capo_cloudfront.types.kinesis_stream_config.KinesisStreamConfig"
+    ]
+    """<p>Contains information about the Amazon Kinesis data stream where you are sending real-time log data in a real-time log configuration.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: EndPoint, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "StreamType").text = str(value["stream_type"])
+    if "kinesis_stream_config" in value:
+        import capo_cloudfront.types.kinesis_stream_config
+
+        capo_cloudfront.types.kinesis_stream_config.serialize_xml(
+            value["kinesis_stream_config"], el, "KinesisStreamConfig"
+        )
+
+
+def deserialize_xml(el: Element) -> EndPoint:
+    out: EndPoint = {}  # type: ignore[typeddict-item]
+    child_stream_type = el.find("StreamType")
+    if child_stream_type is not None:
+        out["stream_type"] = str(child_stream_type.text or "")
+    else:
+        raise DeserializationError("EndPoint.stream_type required")
+    child_kinesis_stream_config = el.find("KinesisStreamConfig")
+    if child_kinesis_stream_config is not None:
+        import capo_cloudfront.types.kinesis_stream_config
+
+        out["kinesis_stream_config"] = (
+            capo_cloudfront.types.kinesis_stream_config.deserialize_xml(
+                child_kinesis_stream_config
+            )
+        )
+    return out

capo_cloudfront/types/end_point_list.py

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

capo_cloudfront/types/event_type.py

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

capo_cloudfront/types/field_level_encryption.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#FieldLevelEncryption``."""
+
+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.field_level_encryption_config
+    import capo_cloudfront.types.string
+    import capo_cloudfront.types.timestamp
+
+
+class FieldLevelEncryption(TypedDict, closed=True):
+    id: "capo_cloudfront.types.string.string"
+    """<p>The configuration ID for a field-level encryption configuration which includes a set of profiles that specify certain selected data fields to be encrypted by specific public keys.</p>"""
+    last_modified_time: "capo_cloudfront.types.timestamp.timestamp"
+    """<p>The last time the field-level encryption configuration was changed.</p>"""
+    field_level_encryption_config: (
+        "capo_cloudfront.types.field_level_encryption_config.FieldLevelEncryptionConfig"
+    )
+    """<p>A complex data type that includes the profile configurations specified for field-level encryption.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: FieldLevelEncryption, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Id").text = str(value["id"])
+    import capo_cloudfront.types.timestamp
+
+    capo_cloudfront.types.timestamp.serialize_xml(
+        value["last_modified_time"], el, "LastModifiedTime"
+    )
+    import capo_cloudfront.types.field_level_encryption_config
+
+    capo_cloudfront.types.field_level_encryption_config.serialize_xml(
+        value["field_level_encryption_config"], el, "FieldLevelEncryptionConfig"
+    )
+
+
+def deserialize_xml(el: Element) -> FieldLevelEncryption:
+    out: FieldLevelEncryption = {}  # 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("FieldLevelEncryption.id required")
+    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
+        )
+    else:
+        raise DeserializationError("FieldLevelEncryption.last_modified_time required")
+    child_field_level_encryption_config = el.find("FieldLevelEncryptionConfig")
+    if child_field_level_encryption_config is not None:
+        import capo_cloudfront.types.field_level_encryption_config
+
+        out["field_level_encryption_config"] = (
+            capo_cloudfront.types.field_level_encryption_config.deserialize_xml(
+                child_field_level_encryption_config
+            )
+        )
+    else:
+        raise DeserializationError(
+            "FieldLevelEncryption.field_level_encryption_config required"
+        )
+    return out

capo_cloudfront/types/field_level_encryption_config.py

@@ -0,0 +1,81 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#FieldLevelEncryptionConfig``."""
+
+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.content_type_profile_config
+    import capo_cloudfront.types.query_arg_profile_config
+    import capo_cloudfront.types.string
+
+
+class FieldLevelEncryptionConfig(TypedDict, closed=True):
+    caller_reference: "capo_cloudfront.types.string.string"
+    """<p>A unique number that ensures the request can't be replayed.</p>"""
+    comment: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>An optional comment about the configuration. The comment cannot be longer than 128 characters.</p>"""
+    query_arg_profile_config: NotRequired[
+        "capo_cloudfront.types.query_arg_profile_config.QueryArgProfileConfig"
+    ]
+    """<p>A complex data type that specifies when to forward content if a profile isn't found and the profile that can be provided as a query argument in a request.</p>"""
+    content_type_profile_config: NotRequired[
+        "capo_cloudfront.types.content_type_profile_config.ContentTypeProfileConfig"
+    ]
+    """<p>A complex data type that specifies when to forward content if a content type isn't recognized and profiles to use as by default in a request if a query argument doesn't specify a profile to use.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: FieldLevelEncryptionConfig, parent: Element, tag: str) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "CallerReference").text = str(value["caller_reference"])
+    if "comment" in value:
+        SubElement(el, "Comment").text = str(value["comment"])
+    if "query_arg_profile_config" in value:
+        import capo_cloudfront.types.query_arg_profile_config
+
+        capo_cloudfront.types.query_arg_profile_config.serialize_xml(
+            value["query_arg_profile_config"], el, "QueryArgProfileConfig"
+        )
+    if "content_type_profile_config" in value:
+        import capo_cloudfront.types.content_type_profile_config
+
+        capo_cloudfront.types.content_type_profile_config.serialize_xml(
+            value["content_type_profile_config"], el, "ContentTypeProfileConfig"
+        )
+
+
+def deserialize_xml(el: Element) -> FieldLevelEncryptionConfig:
+    out: FieldLevelEncryptionConfig = {}  # 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(
+            "FieldLevelEncryptionConfig.caller_reference required"
+        )
+    child_comment = el.find("Comment")
+    if child_comment is not None:
+        out["comment"] = str(child_comment.text or "")
+    child_query_arg_profile_config = el.find("QueryArgProfileConfig")
+    if child_query_arg_profile_config is not None:
+        import capo_cloudfront.types.query_arg_profile_config
+
+        out["query_arg_profile_config"] = (
+            capo_cloudfront.types.query_arg_profile_config.deserialize_xml(
+                child_query_arg_profile_config
+            )
+        )
+    child_content_type_profile_config = el.find("ContentTypeProfileConfig")
+    if child_content_type_profile_config is not None:
+        import capo_cloudfront.types.content_type_profile_config
+
+        out["content_type_profile_config"] = (
+            capo_cloudfront.types.content_type_profile_config.deserialize_xml(
+                child_content_type_profile_config
+            )
+        )
+    return out

capo_cloudfront/types/field_level_encryption_list.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#FieldLevelEncryptionList``."""
+
+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.field_level_encryption_summary_list
+    import capo_cloudfront.types.integer
+    import capo_cloudfront.types.string
+
+
+class FieldLevelEncryptionList(TypedDict, closed=True):
+    next_marker: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>If there are more elements to be listed, this element is present and contains the value that you can use for the <code>Marker</code> request parameter to continue listing your configurations where you left off.</p>"""
+    max_items: "capo_cloudfront.types.integer.integer"
+    """<p>The maximum number of elements you want in the response body.</p>"""
+    quantity: "capo_cloudfront.types.integer.integer"
+    """<p>The number of field-level encryption items.</p>"""
+    items: NotRequired[
+        "capo_cloudfront.types.field_level_encryption_summary_list.FieldLevelEncryptionSummaryList"
+    ]
+    """<p>An array of field-level encryption items.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(value: FieldLevelEncryptionList, 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.field_level_encryption_summary_list
+
+        capo_cloudfront.types.field_level_encryption_summary_list.serialize_xml(
+            value["items"], el, "Items"
+        )
+
+
+def deserialize_xml(el: Element) -> FieldLevelEncryptionList:
+    out: FieldLevelEncryptionList = {}  # 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("FieldLevelEncryptionList.max_items required")
+    child_quantity = el.find("Quantity")
+    if child_quantity is not None:
+        out["quantity"] = int(child_quantity.text or "")
+    else:
+        raise DeserializationError("FieldLevelEncryptionList.quantity required")
+    child_items = el.find("Items")
+    if child_items is not None:
+        import capo_cloudfront.types.field_level_encryption_summary_list
+
+        out["items"] = (
+            capo_cloudfront.types.field_level_encryption_summary_list.deserialize_xml(
+                child_items
+            )
+        )
+    return out

capo_cloudfront/types/field_level_encryption_profile.py

@@ -0,0 +1,78 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#FieldLevelEncryptionProfile``."""
+
+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.field_level_encryption_profile_config
+    import capo_cloudfront.types.string
+    import capo_cloudfront.types.timestamp
+
+
+class FieldLevelEncryptionProfile(TypedDict, closed=True):
+    id: "capo_cloudfront.types.string.string"
+    """<p>The ID for a field-level encryption profile configuration which includes a set of profiles that specify certain selected data fields to be encrypted by specific public keys.</p>"""
+    last_modified_time: "capo_cloudfront.types.timestamp.timestamp"
+    """<p>The last time the field-level encryption profile was updated.</p>"""
+    field_level_encryption_profile_config: "capo_cloudfront.types.field_level_encryption_profile_config.FieldLevelEncryptionProfileConfig"
+    """<p>A complex data type that includes the profile name and the encryption entities for the field-level encryption profile.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: FieldLevelEncryptionProfile, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Id").text = str(value["id"])
+    import capo_cloudfront.types.timestamp
+
+    capo_cloudfront.types.timestamp.serialize_xml(
+        value["last_modified_time"], el, "LastModifiedTime"
+    )
+    import capo_cloudfront.types.field_level_encryption_profile_config
+
+    capo_cloudfront.types.field_level_encryption_profile_config.serialize_xml(
+        value["field_level_encryption_profile_config"],
+        el,
+        "FieldLevelEncryptionProfileConfig",
+    )
+
+
+def deserialize_xml(el: Element) -> FieldLevelEncryptionProfile:
+    out: FieldLevelEncryptionProfile = {}  # 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("FieldLevelEncryptionProfile.id required")
+    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
+        )
+    else:
+        raise DeserializationError(
+            "FieldLevelEncryptionProfile.last_modified_time required"
+        )
+    child_field_level_encryption_profile_config = el.find(
+        "FieldLevelEncryptionProfileConfig"
+    )
+    if child_field_level_encryption_profile_config is not None:
+        import capo_cloudfront.types.field_level_encryption_profile_config
+
+        out["field_level_encryption_profile_config"] = (
+            capo_cloudfront.types.field_level_encryption_profile_config.deserialize_xml(
+                child_field_level_encryption_profile_config
+            )
+        )
+    else:
+        raise DeserializationError(
+            "FieldLevelEncryptionProfile.field_level_encryption_profile_config required"
+        )
+    return out

capo_cloudfront/types/field_level_encryption_profile_config.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#FieldLevelEncryptionProfileConfig``."""
+
+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.encryption_entities
+    import capo_cloudfront.types.string
+
+
+class FieldLevelEncryptionProfileConfig(TypedDict, closed=True):
+    name: "capo_cloudfront.types.string.string"
+    """<p>Profile name for the field-level encryption profile.</p>"""
+    caller_reference: "capo_cloudfront.types.string.string"
+    """<p>A unique number that ensures that the request can't be replayed.</p>"""
+    comment: NotRequired["capo_cloudfront.types.string.string"]
+    """<p>An optional comment for the field-level encryption profile. The comment cannot be longer than 128 characters.</p>"""
+    encryption_entities: "capo_cloudfront.types.encryption_entities.EncryptionEntities"
+    """<p>A complex data type of encryption entities for the field-level encryption profile that include the public key ID, provider, and field patterns for specifying which fields to encrypt with this key.</p>"""
+
+
+# --- restXml ser/de ---
+def serialize_xml(
+    value: FieldLevelEncryptionProfileConfig, parent: Element, tag: str
+) -> None:
+    el = SubElement(parent, tag)
+    SubElement(el, "Name").text = str(value["name"])
+    SubElement(el, "CallerReference").text = str(value["caller_reference"])
+    if "comment" in value:
+        SubElement(el, "Comment").text = str(value["comment"])
+    import capo_cloudfront.types.encryption_entities
+
+    capo_cloudfront.types.encryption_entities.serialize_xml(
+        value["encryption_entities"], el, "EncryptionEntities"
+    )
+
+
+def deserialize_xml(el: Element) -> FieldLevelEncryptionProfileConfig:
+    out: FieldLevelEncryptionProfileConfig = {}  # 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("FieldLevelEncryptionProfileConfig.name required")
+    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(
+            "FieldLevelEncryptionProfileConfig.caller_reference required"
+        )
+    child_comment = el.find("Comment")
+    if child_comment is not None:
+        out["comment"] = str(child_comment.text or "")
+    child_encryption_entities = el.find("EncryptionEntities")
+    if child_encryption_entities is not None:
+        import capo_cloudfront.types.encryption_entities
+
+        out["encryption_entities"] = (
+            capo_cloudfront.types.encryption_entities.deserialize_xml(
+                child_encryption_entities
+            )
+        )
+    else:
+        raise DeserializationError(
+            "FieldLevelEncryptionProfileConfig.encryption_entities required"
+        )
+    return out