capo-cloudfront 0.2.0__py3-none-any.whl

capo_cloudfront/_operations/cloudfront2020_05_31/create_distribution_with_tags.py

@@ -0,0 +1,468 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateDistributionWithTags``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import zapros
+from typing_extensions import Never
+
+import capo_cloudfront._auth._signers
+import capo_cloudfront._auth._sigv4
+import capo_cloudfront.errors.access_denied
+import capo_cloudfront.errors.cname_already_exists
+import capo_cloudfront.errors.continuous_deployment_policy_in_use
+import capo_cloudfront.errors.distribution_already_exists
+import capo_cloudfront.errors.entity_not_found
+import capo_cloudfront.errors.illegal_field_level_encryption_config_association_with_cache_behavior
+import capo_cloudfront.errors.illegal_origin_access_configuration
+import capo_cloudfront.errors.inconsistent_quantities
+import capo_cloudfront.errors.invalid_argument
+import capo_cloudfront.errors.invalid_default_root_object
+import capo_cloudfront.errors.invalid_domain_name_for_origin_access_control
+import capo_cloudfront.errors.invalid_error_code
+import capo_cloudfront.errors.invalid_forward_cookies
+import capo_cloudfront.errors.invalid_function_association
+import capo_cloudfront.errors.invalid_geo_restriction_parameter
+import capo_cloudfront.errors.invalid_headers_for_s3_origin
+import capo_cloudfront.errors.invalid_lambda_function_association
+import capo_cloudfront.errors.invalid_location_code
+import capo_cloudfront.errors.invalid_minimum_protocol_version
+import capo_cloudfront.errors.invalid_origin
+import capo_cloudfront.errors.invalid_origin_access_control
+import capo_cloudfront.errors.invalid_origin_access_identity
+import capo_cloudfront.errors.invalid_origin_keepalive_timeout
+import capo_cloudfront.errors.invalid_origin_read_timeout
+import capo_cloudfront.errors.invalid_protocol_settings
+import capo_cloudfront.errors.invalid_query_string_parameters
+import capo_cloudfront.errors.invalid_relative_path
+import capo_cloudfront.errors.invalid_required_protocol
+import capo_cloudfront.errors.invalid_response_code
+import capo_cloudfront.errors.invalid_tagging
+import capo_cloudfront.errors.invalid_ttl_order
+import capo_cloudfront.errors.invalid_viewer_certificate
+import capo_cloudfront.errors.invalid_web_acl_id
+import capo_cloudfront.errors.missing_body
+import capo_cloudfront.errors.no_such_cache_policy
+import capo_cloudfront.errors.no_such_continuous_deployment_policy
+import capo_cloudfront.errors.no_such_field_level_encryption_config
+import capo_cloudfront.errors.no_such_origin
+import capo_cloudfront.errors.no_such_origin_request_policy
+import capo_cloudfront.errors.no_such_realtime_log_config
+import capo_cloudfront.errors.no_such_response_headers_policy
+import capo_cloudfront.errors.realtime_log_config_owner_mismatch
+import capo_cloudfront.errors.too_many_cache_behaviors
+import capo_cloudfront.errors.too_many_certificates
+import capo_cloudfront.errors.too_many_cookie_names_in_white_list
+import capo_cloudfront.errors.too_many_distribution_cnam_es
+import capo_cloudfront.errors.too_many_distributions
+import capo_cloudfront.errors.too_many_distributions_associated_to_cache_policy
+import capo_cloudfront.errors.too_many_distributions_associated_to_field_level_encryption_config
+import capo_cloudfront.errors.too_many_distributions_associated_to_key_group
+import capo_cloudfront.errors.too_many_distributions_associated_to_origin_access_control
+import capo_cloudfront.errors.too_many_distributions_associated_to_origin_request_policy
+import capo_cloudfront.errors.too_many_distributions_associated_to_response_headers_policy
+import capo_cloudfront.errors.too_many_distributions_with_function_associations
+import capo_cloudfront.errors.too_many_distributions_with_lambda_associations
+import capo_cloudfront.errors.too_many_distributions_with_single_function_arn
+import capo_cloudfront.errors.too_many_function_associations
+import capo_cloudfront.errors.too_many_headers_in_forwarded_values
+import capo_cloudfront.errors.too_many_key_groups_associated_to_distribution
+import capo_cloudfront.errors.too_many_lambda_function_associations
+import capo_cloudfront.errors.too_many_origin_custom_headers
+import capo_cloudfront.errors.too_many_origin_groups_per_distribution
+import capo_cloudfront.errors.too_many_origins
+import capo_cloudfront.errors.too_many_query_string_parameters
+import capo_cloudfront.errors.too_many_trusted_signers
+import capo_cloudfront.errors.trusted_key_group_does_not_exist
+import capo_cloudfront.errors.trusted_signer_does_not_exist
+import capo_cloudfront.types.create_distribution_with_tags_request
+import capo_cloudfront.types.create_distribution_with_tags_result
+import capo_cloudfront.types.distribution
+import capo_cloudfront.types.distribution_config_with_tags
+from capo_cloudfront._protocol.errors import parse_error_metadata
+from capo_cloudfront._protocol.xml import Element, fromstring, tostring
+from capo_cloudfront._rule_engine._endpoint_rule_set import EndpointParams, resolve
+from capo_cloudfront._services._pipeline import AsyncOperationOptions, OperationOptions
+from capo_cloudfront.errors import UnknownServiceError
+
+
+def handle_error(response: zapros.Response) -> Never:
+    root = fromstring(response.read())
+    code, message = parse_error_metadata(root)
+    match code:
+        case "AccessDenied":
+            raise capo_cloudfront.errors.access_denied.AccessDenied.from_xml(root)
+        case "CNAMEAlreadyExists":
+            raise capo_cloudfront.errors.cname_already_exists.CNAMEAlreadyExists.from_xml(
+                root
+            )
+        case "ContinuousDeploymentPolicyInUse":
+            raise capo_cloudfront.errors.continuous_deployment_policy_in_use.ContinuousDeploymentPolicyInUse.from_xml(
+                root
+            )
+        case "DistributionAlreadyExists":
+            raise capo_cloudfront.errors.distribution_already_exists.DistributionAlreadyExists.from_xml(
+                root
+            )
+        case "EntityNotFound":
+            raise capo_cloudfront.errors.entity_not_found.EntityNotFound.from_xml(root)
+        case "IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior":
+            raise capo_cloudfront.errors.illegal_field_level_encryption_config_association_with_cache_behavior.IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior.from_xml(
+                root
+            )
+        case "IllegalOriginAccessConfiguration":
+            raise capo_cloudfront.errors.illegal_origin_access_configuration.IllegalOriginAccessConfiguration.from_xml(
+                root
+            )
+        case "InconsistentQuantities":
+            raise capo_cloudfront.errors.inconsistent_quantities.InconsistentQuantities.from_xml(
+                root
+            )
+        case "InvalidArgument":
+            raise capo_cloudfront.errors.invalid_argument.InvalidArgument.from_xml(root)
+        case "InvalidDefaultRootObject":
+            raise capo_cloudfront.errors.invalid_default_root_object.InvalidDefaultRootObject.from_xml(
+                root
+            )
+        case "InvalidDomainNameForOriginAccessControl":
+            raise capo_cloudfront.errors.invalid_domain_name_for_origin_access_control.InvalidDomainNameForOriginAccessControl.from_xml(
+                root
+            )
+        case "InvalidErrorCode":
+            raise capo_cloudfront.errors.invalid_error_code.InvalidErrorCode.from_xml(
+                root
+            )
+        case "InvalidForwardCookies":
+            raise capo_cloudfront.errors.invalid_forward_cookies.InvalidForwardCookies.from_xml(
+                root
+            )
+        case "InvalidFunctionAssociation":
+            raise capo_cloudfront.errors.invalid_function_association.InvalidFunctionAssociation.from_xml(
+                root
+            )
+        case "InvalidGeoRestrictionParameter":
+            raise capo_cloudfront.errors.invalid_geo_restriction_parameter.InvalidGeoRestrictionParameter.from_xml(
+                root
+            )
+        case "InvalidHeadersForS3Origin":
+            raise capo_cloudfront.errors.invalid_headers_for_s3_origin.InvalidHeadersForS3Origin.from_xml(
+                root
+            )
+        case "InvalidLambdaFunctionAssociation":
+            raise capo_cloudfront.errors.invalid_lambda_function_association.InvalidLambdaFunctionAssociation.from_xml(
+                root
+            )
+        case "InvalidLocationCode":
+            raise capo_cloudfront.errors.invalid_location_code.InvalidLocationCode.from_xml(
+                root
+            )
+        case "InvalidMinimumProtocolVersion":
+            raise capo_cloudfront.errors.invalid_minimum_protocol_version.InvalidMinimumProtocolVersion.from_xml(
+                root
+            )
+        case "InvalidOrigin":
+            raise capo_cloudfront.errors.invalid_origin.InvalidOrigin.from_xml(root)
+        case "InvalidOriginAccessControl":
+            raise capo_cloudfront.errors.invalid_origin_access_control.InvalidOriginAccessControl.from_xml(
+                root
+            )
+        case "InvalidOriginAccessIdentity":
+            raise capo_cloudfront.errors.invalid_origin_access_identity.InvalidOriginAccessIdentity.from_xml(
+                root
+            )
+        case "InvalidOriginKeepaliveTimeout":
+            raise capo_cloudfront.errors.invalid_origin_keepalive_timeout.InvalidOriginKeepaliveTimeout.from_xml(
+                root
+            )
+        case "InvalidOriginReadTimeout":
+            raise capo_cloudfront.errors.invalid_origin_read_timeout.InvalidOriginReadTimeout.from_xml(
+                root
+            )
+        case "InvalidProtocolSettings":
+            raise capo_cloudfront.errors.invalid_protocol_settings.InvalidProtocolSettings.from_xml(
+                root
+            )
+        case "InvalidQueryStringParameters":
+            raise capo_cloudfront.errors.invalid_query_string_parameters.InvalidQueryStringParameters.from_xml(
+                root
+            )
+        case "InvalidRelativePath":
+            raise capo_cloudfront.errors.invalid_relative_path.InvalidRelativePath.from_xml(
+                root
+            )
+        case "InvalidRequiredProtocol":
+            raise capo_cloudfront.errors.invalid_required_protocol.InvalidRequiredProtocol.from_xml(
+                root
+            )
+        case "InvalidResponseCode":
+            raise capo_cloudfront.errors.invalid_response_code.InvalidResponseCode.from_xml(
+                root
+            )
+        case "InvalidTagging":
+            raise capo_cloudfront.errors.invalid_tagging.InvalidTagging.from_xml(root)
+        case "InvalidTTLOrder":
+            raise capo_cloudfront.errors.invalid_ttl_order.InvalidTTLOrder.from_xml(
+                root
+            )
+        case "InvalidViewerCertificate":
+            raise capo_cloudfront.errors.invalid_viewer_certificate.InvalidViewerCertificate.from_xml(
+                root
+            )
+        case "InvalidWebACLId":
+            raise capo_cloudfront.errors.invalid_web_acl_id.InvalidWebACLId.from_xml(
+                root
+            )
+        case "MissingBody":
+            raise capo_cloudfront.errors.missing_body.MissingBody.from_xml(root)
+        case "NoSuchCachePolicy":
+            raise capo_cloudfront.errors.no_such_cache_policy.NoSuchCachePolicy.from_xml(
+                root
+            )
+        case "NoSuchContinuousDeploymentPolicy":
+            raise capo_cloudfront.errors.no_such_continuous_deployment_policy.NoSuchContinuousDeploymentPolicy.from_xml(
+                root
+            )
+        case "NoSuchFieldLevelEncryptionConfig":
+            raise capo_cloudfront.errors.no_such_field_level_encryption_config.NoSuchFieldLevelEncryptionConfig.from_xml(
+                root
+            )
+        case "NoSuchOrigin":
+            raise capo_cloudfront.errors.no_such_origin.NoSuchOrigin.from_xml(root)
+        case "NoSuchOriginRequestPolicy":
+            raise capo_cloudfront.errors.no_such_origin_request_policy.NoSuchOriginRequestPolicy.from_xml(
+                root
+            )
+        case "NoSuchRealtimeLogConfig":
+            raise capo_cloudfront.errors.no_such_realtime_log_config.NoSuchRealtimeLogConfig.from_xml(
+                root
+            )
+        case "NoSuchResponseHeadersPolicy":
+            raise capo_cloudfront.errors.no_such_response_headers_policy.NoSuchResponseHeadersPolicy.from_xml(
+                root
+            )
+        case "RealtimeLogConfigOwnerMismatch":
+            raise capo_cloudfront.errors.realtime_log_config_owner_mismatch.RealtimeLogConfigOwnerMismatch.from_xml(
+                root
+            )
+        case "TooManyCacheBehaviors":
+            raise capo_cloudfront.errors.too_many_cache_behaviors.TooManyCacheBehaviors.from_xml(
+                root
+            )
+        case "TooManyCertificates":
+            raise capo_cloudfront.errors.too_many_certificates.TooManyCertificates.from_xml(
+                root
+            )
+        case "TooManyCookieNamesInWhiteList":
+            raise capo_cloudfront.errors.too_many_cookie_names_in_white_list.TooManyCookieNamesInWhiteList.from_xml(
+                root
+            )
+        case "TooManyDistributionCNAMEs":
+            raise capo_cloudfront.errors.too_many_distribution_cnam_es.TooManyDistributionCNAMEs.from_xml(
+                root
+            )
+        case "TooManyDistributions":
+            raise capo_cloudfront.errors.too_many_distributions.TooManyDistributions.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToCachePolicy":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_cache_policy.TooManyDistributionsAssociatedToCachePolicy.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToFieldLevelEncryptionConfig":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_field_level_encryption_config.TooManyDistributionsAssociatedToFieldLevelEncryptionConfig.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToKeyGroup":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_key_group.TooManyDistributionsAssociatedToKeyGroup.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToOriginAccessControl":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_origin_access_control.TooManyDistributionsAssociatedToOriginAccessControl.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToOriginRequestPolicy":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_origin_request_policy.TooManyDistributionsAssociatedToOriginRequestPolicy.from_xml(
+                root
+            )
+        case "TooManyDistributionsAssociatedToResponseHeadersPolicy":
+            raise capo_cloudfront.errors.too_many_distributions_associated_to_response_headers_policy.TooManyDistributionsAssociatedToResponseHeadersPolicy.from_xml(
+                root
+            )
+        case "TooManyDistributionsWithFunctionAssociations":
+            raise capo_cloudfront.errors.too_many_distributions_with_function_associations.TooManyDistributionsWithFunctionAssociations.from_xml(
+                root
+            )
+        case "TooManyDistributionsWithLambdaAssociations":
+            raise capo_cloudfront.errors.too_many_distributions_with_lambda_associations.TooManyDistributionsWithLambdaAssociations.from_xml(
+                root
+            )
+        case "TooManyDistributionsWithSingleFunctionARN":
+            raise capo_cloudfront.errors.too_many_distributions_with_single_function_arn.TooManyDistributionsWithSingleFunctionARN.from_xml(
+                root
+            )
+        case "TooManyFunctionAssociations":
+            raise capo_cloudfront.errors.too_many_function_associations.TooManyFunctionAssociations.from_xml(
+                root
+            )
+        case "TooManyHeadersInForwardedValues":
+            raise capo_cloudfront.errors.too_many_headers_in_forwarded_values.TooManyHeadersInForwardedValues.from_xml(
+                root
+            )
+        case "TooManyKeyGroupsAssociatedToDistribution":
+            raise capo_cloudfront.errors.too_many_key_groups_associated_to_distribution.TooManyKeyGroupsAssociatedToDistribution.from_xml(
+                root
+            )
+        case "TooManyLambdaFunctionAssociations":
+            raise capo_cloudfront.errors.too_many_lambda_function_associations.TooManyLambdaFunctionAssociations.from_xml(
+                root
+            )
+        case "TooManyOriginCustomHeaders":
+            raise capo_cloudfront.errors.too_many_origin_custom_headers.TooManyOriginCustomHeaders.from_xml(
+                root
+            )
+        case "TooManyOriginGroupsPerDistribution":
+            raise capo_cloudfront.errors.too_many_origin_groups_per_distribution.TooManyOriginGroupsPerDistribution.from_xml(
+                root
+            )
+        case "TooManyOrigins":
+            raise capo_cloudfront.errors.too_many_origins.TooManyOrigins.from_xml(root)
+        case "TooManyQueryStringParameters":
+            raise capo_cloudfront.errors.too_many_query_string_parameters.TooManyQueryStringParameters.from_xml(
+                root
+            )
+        case "TooManyTrustedSigners":
+            raise capo_cloudfront.errors.too_many_trusted_signers.TooManyTrustedSigners.from_xml(
+                root
+            )
+        case "TrustedKeyGroupDoesNotExist":
+            raise capo_cloudfront.errors.trusted_key_group_does_not_exist.TrustedKeyGroupDoesNotExist.from_xml(
+                root
+            )
+        case "TrustedSignerDoesNotExist":
+            raise capo_cloudfront.errors.trusted_signer_does_not_exist.TrustedSignerDoesNotExist.from_xml(
+                root
+            )
+        case _:
+            raise UnknownServiceError(code=code, message=message, response=response)
+
+
+def handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult:
+    out: capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult = {
+        "distribution": capo_cloudfront.types.distribution.deserialize_xml(
+            fromstring(response.read())
+        )
+    }  # type: ignore[typeddict-item]
+    if "Location" in response.headers:
+        out["location"] = str(response.headers["Location"])
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+async def async_handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult:
+    out: capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult = {
+        "distribution": capo_cloudfront.types.distribution.deserialize_xml(
+            fromstring(await response.aread())
+        )
+    }  # type: ignore[typeddict-item]
+    if "Location" in response.headers:
+        out["location"] = str(response.headers["Location"])
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+def get_signer(
+    options: AsyncOperationOptions | OperationOptions,
+    auth_schemes: list[dict[str, Any]] | None = None,
+) -> capo_cloudfront._auth._signers.Signer | None:
+    name_to_schema = {s["name"]: s for s in (auth_schemes or [])}  # noqa: F841
+    if options.credentials_provider is not None:
+        sigv4_config = (
+            name_to_schema.get("sigv4")
+            or name_to_schema.get("sigv4a")
+            or name_to_schema.get("sigv4-s3express")
+            or capo_cloudfront._auth._sigv4.build_sigv4_auth_scheme(
+                "cloudfront", options.region
+            )
+        )
+        if sigv4_config is not None:
+            return capo_cloudfront._auth._signers.SigV4Signer(
+                options.credentials_provider, auth_scheme=sigv4_config
+            )
+    raise RuntimeError("Auth was not resolved")
+
+
+def build_request(
+    options: OperationOptions | AsyncOperationOptions,
+    input_: capo_cloudfront.types.create_distribution_with_tags_request.CreateDistributionWithTagsRequest,
+) -> zapros.Request:
+    endpoint = resolve(
+        EndpointParams(
+            UseDualStack=options.use_dual_stack,
+            UseFIPS=options.use_fips,
+            Endpoint=options.endpoint,
+            Region=options.region,
+        )
+    )  # noqa: F841
+    url = endpoint.url.rstrip("/") + "/2020-05-31/distribution?WithTags"
+    params: dict[str, str] = {}
+    headers: dict[str, str] = {k: ", ".join(v) for k, v in endpoint.headers.items()}
+    if "distribution_config_with_tags" in input_:
+        payload_root = Element("_")
+        capo_cloudfront.types.distribution_config_with_tags.serialize_xml(
+            input_["distribution_config_with_tags"],
+            payload_root,
+            "DistributionConfigWithTags",
+        )
+        body: bytes | None = tostring(payload_root[0])
+        headers["content-type"] = "application/xml"
+    else:
+        body = b""
+    signer = get_signer(options, auth_schemes=endpoint.properties.get("authSchemes"))
+    normalized_url = zapros.URL(url)
+    normalized_url.search_params.update(params)
+    return zapros.Request(
+        normalized_url, "POST", headers=headers, body=body, context={"signer": signer}
+    )
+
+
+def create_distribution_with_tags(
+    options: OperationOptions,
+    input_: capo_cloudfront.types.create_distribution_with_tags_request.CreateDistributionWithTagsRequest,
+) -> tuple[
+    capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult,
+    zapros.Response,
+]:
+    response = options.client.handler.handle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            response.read()
+            handle_error(response)
+        return handle_response(response), response
+    except BaseException:
+        response.close()
+        raise
+
+
+async def async_create_distribution_with_tags(
+    options: AsyncOperationOptions,
+    input_: capo_cloudfront.types.create_distribution_with_tags_request.CreateDistributionWithTagsRequest,
+) -> tuple[
+    capo_cloudfront.types.create_distribution_with_tags_result.CreateDistributionWithTagsResult,
+    zapros.Response,
+]:
+    response = await options.client.handler.ahandle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            await response.aread()
+            handle_error(response)
+        return await async_handle_response(response), response
+    except BaseException:
+        await response.aclose()
+        raise

capo_cloudfront/_operations/cloudfront2020_05_31/create_field_level_encryption_config.py

@@ -0,0 +1,187 @@
+"""Generated from Smithy shape ``com.amazonaws.cloudfront#CreateFieldLevelEncryptionConfig``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import zapros
+from typing_extensions import Never
+
+import capo_cloudfront._auth._signers
+import capo_cloudfront._auth._sigv4
+import capo_cloudfront.errors.field_level_encryption_config_already_exists
+import capo_cloudfront.errors.inconsistent_quantities
+import capo_cloudfront.errors.invalid_argument
+import capo_cloudfront.errors.no_such_field_level_encryption_profile
+import capo_cloudfront.errors.query_arg_profile_empty
+import capo_cloudfront.errors.too_many_field_level_encryption_configs
+import capo_cloudfront.errors.too_many_field_level_encryption_content_type_profiles
+import capo_cloudfront.errors.too_many_field_level_encryption_query_arg_profiles
+import capo_cloudfront.types.create_field_level_encryption_config_request
+import capo_cloudfront.types.create_field_level_encryption_config_result
+import capo_cloudfront.types.field_level_encryption
+import capo_cloudfront.types.field_level_encryption_config
+from capo_cloudfront._protocol.errors import parse_error_metadata
+from capo_cloudfront._protocol.xml import Element, fromstring, tostring
+from capo_cloudfront._rule_engine._endpoint_rule_set import EndpointParams, resolve
+from capo_cloudfront._services._pipeline import AsyncOperationOptions, OperationOptions
+from capo_cloudfront.errors import UnknownServiceError
+
+
+def handle_error(response: zapros.Response) -> Never:
+    root = fromstring(response.read())
+    code, message = parse_error_metadata(root)
+    match code:
+        case "FieldLevelEncryptionConfigAlreadyExists":
+            raise capo_cloudfront.errors.field_level_encryption_config_already_exists.FieldLevelEncryptionConfigAlreadyExists.from_xml(
+                root
+            )
+        case "InconsistentQuantities":
+            raise capo_cloudfront.errors.inconsistent_quantities.InconsistentQuantities.from_xml(
+                root
+            )
+        case "InvalidArgument":
+            raise capo_cloudfront.errors.invalid_argument.InvalidArgument.from_xml(root)
+        case "NoSuchFieldLevelEncryptionProfile":
+            raise capo_cloudfront.errors.no_such_field_level_encryption_profile.NoSuchFieldLevelEncryptionProfile.from_xml(
+                root
+            )
+        case "QueryArgProfileEmpty":
+            raise capo_cloudfront.errors.query_arg_profile_empty.QueryArgProfileEmpty.from_xml(
+                root
+            )
+        case "TooManyFieldLevelEncryptionConfigs":
+            raise capo_cloudfront.errors.too_many_field_level_encryption_configs.TooManyFieldLevelEncryptionConfigs.from_xml(
+                root
+            )
+        case "TooManyFieldLevelEncryptionContentTypeProfiles":
+            raise capo_cloudfront.errors.too_many_field_level_encryption_content_type_profiles.TooManyFieldLevelEncryptionContentTypeProfiles.from_xml(
+                root
+            )
+        case "TooManyFieldLevelEncryptionQueryArgProfiles":
+            raise capo_cloudfront.errors.too_many_field_level_encryption_query_arg_profiles.TooManyFieldLevelEncryptionQueryArgProfiles.from_xml(
+                root
+            )
+        case _:
+            raise UnknownServiceError(code=code, message=message, response=response)
+
+
+def handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult:
+    out: capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult = {
+        "field_level_encryption": capo_cloudfront.types.field_level_encryption.deserialize_xml(
+            fromstring(response.read())
+        )
+    }  # type: ignore[typeddict-item]
+    if "Location" in response.headers:
+        out["location"] = str(response.headers["Location"])
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+async def async_handle_response(
+    response: zapros.Response,
+) -> capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult:
+    out: capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult = {
+        "field_level_encryption": capo_cloudfront.types.field_level_encryption.deserialize_xml(
+            fromstring(await response.aread())
+        )
+    }  # type: ignore[typeddict-item]
+    if "Location" in response.headers:
+        out["location"] = str(response.headers["Location"])
+    if "ETag" in response.headers:
+        out["e_tag"] = str(response.headers["ETag"])
+    return out
+
+
+def get_signer(
+    options: AsyncOperationOptions | OperationOptions,
+    auth_schemes: list[dict[str, Any]] | None = None,
+) -> capo_cloudfront._auth._signers.Signer | None:
+    name_to_schema = {s["name"]: s for s in (auth_schemes or [])}  # noqa: F841
+    if options.credentials_provider is not None:
+        sigv4_config = (
+            name_to_schema.get("sigv4")
+            or name_to_schema.get("sigv4a")
+            or name_to_schema.get("sigv4-s3express")
+            or capo_cloudfront._auth._sigv4.build_sigv4_auth_scheme(
+                "cloudfront", options.region
+            )
+        )
+        if sigv4_config is not None:
+            return capo_cloudfront._auth._signers.SigV4Signer(
+                options.credentials_provider, auth_scheme=sigv4_config
+            )
+    raise RuntimeError("Auth was not resolved")
+
+
+def build_request(
+    options: OperationOptions | AsyncOperationOptions,
+    input_: capo_cloudfront.types.create_field_level_encryption_config_request.CreateFieldLevelEncryptionConfigRequest,
+) -> zapros.Request:
+    endpoint = resolve(
+        EndpointParams(
+            UseDualStack=options.use_dual_stack,
+            UseFIPS=options.use_fips,
+            Endpoint=options.endpoint,
+            Region=options.region,
+        )
+    )  # noqa: F841
+    url = endpoint.url.rstrip("/") + "/2020-05-31/field-level-encryption"
+    params: dict[str, str] = {}
+    headers: dict[str, str] = {k: ", ".join(v) for k, v in endpoint.headers.items()}
+    if "field_level_encryption_config" in input_:
+        payload_root = Element("_")
+        capo_cloudfront.types.field_level_encryption_config.serialize_xml(
+            input_["field_level_encryption_config"],
+            payload_root,
+            "FieldLevelEncryptionConfig",
+        )
+        body: bytes | None = tostring(payload_root[0])
+        headers["content-type"] = "application/xml"
+    else:
+        body = b""
+    signer = get_signer(options, auth_schemes=endpoint.properties.get("authSchemes"))
+    normalized_url = zapros.URL(url)
+    normalized_url.search_params.update(params)
+    return zapros.Request(
+        normalized_url, "POST", headers=headers, body=body, context={"signer": signer}
+    )
+
+
+def create_field_level_encryption_config(
+    options: OperationOptions,
+    input_: capo_cloudfront.types.create_field_level_encryption_config_request.CreateFieldLevelEncryptionConfigRequest,
+) -> tuple[
+    capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult,
+    zapros.Response,
+]:
+    response = options.client.handler.handle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            response.read()
+            handle_error(response)
+        return handle_response(response), response
+    except BaseException:
+        response.close()
+        raise
+
+
+async def async_create_field_level_encryption_config(
+    options: AsyncOperationOptions,
+    input_: capo_cloudfront.types.create_field_level_encryption_config_request.CreateFieldLevelEncryptionConfigRequest,
+) -> tuple[
+    capo_cloudfront.types.create_field_level_encryption_config_result.CreateFieldLevelEncryptionConfigResult,
+    zapros.Response,
+]:
+    response = await options.client.handler.ahandle(build_request(options, input_))
+    try:
+        if response.status >= 400:
+            await response.aread()
+            handle_error(response)
+        return await async_handle_response(response), response
+    except BaseException:
+        await response.aclose()
+        raise