service/cloudfront/validators.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package cloudfront

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/cloudfront/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpAssociateAlias struct {
}

func (*validateOpAssociateAlias) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAssociateAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AssociateAliasInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAssociateAliasInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAssociateDistributionTenantWebACL struct {
}

func (*validateOpAssociateDistributionTenantWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAssociateDistributionTenantWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AssociateDistributionTenantWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAssociateDistributionTenantWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAssociateDistributionWebACL struct {
}

func (*validateOpAssociateDistributionWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAssociateDistributionWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AssociateDistributionWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAssociateDistributionWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCopyDistribution struct {
}

func (*validateOpCopyDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCopyDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CopyDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCopyDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateAnycastIpList struct {
}

func (*validateOpCreateAnycastIpList) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateAnycastIpList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateAnycastIpListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateAnycastIpListInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateCachePolicy struct {
}

func (*validateOpCreateCachePolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateCachePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateCachePolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateCachePolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateCloudFrontOriginAccessIdentity struct {
}

func (*validateOpCreateCloudFrontOriginAccessIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateCloudFrontOriginAccessIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateCloudFrontOriginAccessIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateCloudFrontOriginAccessIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateConnectionGroup struct {
}

func (*validateOpCreateConnectionGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateConnectionGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateConnectionGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateConnectionGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateContinuousDeploymentPolicy struct {
}

func (*validateOpCreateContinuousDeploymentPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateContinuousDeploymentPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateContinuousDeploymentPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateContinuousDeploymentPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDistribution struct {
}

func (*validateOpCreateDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDistributionTenant struct {
}

func (*validateOpCreateDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDistributionWithTags struct {
}

func (*validateOpCreateDistributionWithTags) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDistributionWithTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDistributionWithTagsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDistributionWithTagsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateFieldLevelEncryptionConfig struct {
}

func (*validateOpCreateFieldLevelEncryptionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateFieldLevelEncryptionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateFieldLevelEncryptionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateFieldLevelEncryptionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateFieldLevelEncryptionProfile struct {
}

func (*validateOpCreateFieldLevelEncryptionProfile) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateFieldLevelEncryptionProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateFieldLevelEncryptionProfileInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateFieldLevelEncryptionProfileInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateFunction struct {
}

func (*validateOpCreateFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateInvalidationForDistributionTenant struct {
}

func (*validateOpCreateInvalidationForDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateInvalidationForDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateInvalidationForDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateInvalidationForDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateInvalidation struct {
}

func (*validateOpCreateInvalidation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateInvalidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateInvalidationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateInvalidationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateKeyGroup struct {
}

func (*validateOpCreateKeyGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateKeyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateKeyGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateKeyGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateKeyValueStore struct {
}

func (*validateOpCreateKeyValueStore) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateKeyValueStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateKeyValueStoreInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateKeyValueStoreInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateMonitoringSubscription struct {
}

func (*validateOpCreateMonitoringSubscription) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateMonitoringSubscription) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateMonitoringSubscriptionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateMonitoringSubscriptionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateOriginAccessControl struct {
}

func (*validateOpCreateOriginAccessControl) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateOriginAccessControl) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateOriginAccessControlInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateOriginAccessControlInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateOriginRequestPolicy struct {
}

func (*validateOpCreateOriginRequestPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateOriginRequestPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateOriginRequestPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateOriginRequestPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreatePublicKey struct {
}

func (*validateOpCreatePublicKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreatePublicKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreatePublicKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreatePublicKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRealtimeLogConfig struct {
}

func (*validateOpCreateRealtimeLogConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRealtimeLogConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRealtimeLogConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRealtimeLogConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateResponseHeadersPolicy struct {
}

func (*validateOpCreateResponseHeadersPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateResponseHeadersPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateResponseHeadersPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateResponseHeadersPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateStreamingDistribution struct {
}

func (*validateOpCreateStreamingDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateStreamingDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateStreamingDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateStreamingDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateStreamingDistributionWithTags struct {
}

func (*validateOpCreateStreamingDistributionWithTags) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateStreamingDistributionWithTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateStreamingDistributionWithTagsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateStreamingDistributionWithTagsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateVpcOrigin struct {
}

func (*validateOpCreateVpcOrigin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateVpcOrigin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateVpcOriginInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateVpcOriginInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteAnycastIpList struct {
}

func (*validateOpDeleteAnycastIpList) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteAnycastIpList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteAnycastIpListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteAnycastIpListInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteCachePolicy struct {
}

func (*validateOpDeleteCachePolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteCachePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteCachePolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteCachePolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteCloudFrontOriginAccessIdentity struct {
}

func (*validateOpDeleteCloudFrontOriginAccessIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteCloudFrontOriginAccessIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteCloudFrontOriginAccessIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteCloudFrontOriginAccessIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConnectionGroup struct {
}

func (*validateOpDeleteConnectionGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConnectionGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConnectionGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConnectionGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteContinuousDeploymentPolicy struct {
}

func (*validateOpDeleteContinuousDeploymentPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteContinuousDeploymentPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteContinuousDeploymentPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteContinuousDeploymentPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDistribution struct {
}

func (*validateOpDeleteDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDistributionTenant struct {
}

func (*validateOpDeleteDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteFieldLevelEncryptionConfig struct {
}

func (*validateOpDeleteFieldLevelEncryptionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteFieldLevelEncryptionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteFieldLevelEncryptionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteFieldLevelEncryptionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteFieldLevelEncryptionProfile struct {
}

func (*validateOpDeleteFieldLevelEncryptionProfile) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteFieldLevelEncryptionProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteFieldLevelEncryptionProfileInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteFieldLevelEncryptionProfileInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteFunction struct {
}

func (*validateOpDeleteFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteKeyGroup struct {
}

func (*validateOpDeleteKeyGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteKeyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteKeyGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteKeyGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteKeyValueStore struct {
}

func (*validateOpDeleteKeyValueStore) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteKeyValueStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteKeyValueStoreInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteKeyValueStoreInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteMonitoringSubscription struct {
}

func (*validateOpDeleteMonitoringSubscription) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteMonitoringSubscription) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteMonitoringSubscriptionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteMonitoringSubscriptionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteOriginAccessControl struct {
}

func (*validateOpDeleteOriginAccessControl) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteOriginAccessControl) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteOriginAccessControlInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteOriginAccessControlInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteOriginRequestPolicy struct {
}

func (*validateOpDeleteOriginRequestPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteOriginRequestPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteOriginRequestPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteOriginRequestPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeletePublicKey struct {
}

func (*validateOpDeletePublicKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeletePublicKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeletePublicKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeletePublicKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteResponseHeadersPolicy struct {
}

func (*validateOpDeleteResponseHeadersPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteResponseHeadersPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteResponseHeadersPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteResponseHeadersPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteStreamingDistribution struct {
}

func (*validateOpDeleteStreamingDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteStreamingDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteStreamingDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteStreamingDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteVpcOrigin struct {
}

func (*validateOpDeleteVpcOrigin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteVpcOrigin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteVpcOriginInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteVpcOriginInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeFunction struct {
}

func (*validateOpDescribeFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeKeyValueStore struct {
}

func (*validateOpDescribeKeyValueStore) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeKeyValueStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeKeyValueStoreInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeKeyValueStoreInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDisassociateDistributionTenantWebACL struct {
}

func (*validateOpDisassociateDistributionTenantWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDisassociateDistributionTenantWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DisassociateDistributionTenantWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDisassociateDistributionTenantWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDisassociateDistributionWebACL struct {
}

func (*validateOpDisassociateDistributionWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDisassociateDistributionWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DisassociateDistributionWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDisassociateDistributionWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAnycastIpList struct {
}

func (*validateOpGetAnycastIpList) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAnycastIpList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAnycastIpListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAnycastIpListInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCachePolicyConfig struct {
}

func (*validateOpGetCachePolicyConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCachePolicyConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCachePolicyConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCachePolicyConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCachePolicy struct {
}

func (*validateOpGetCachePolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCachePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCachePolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCachePolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCloudFrontOriginAccessIdentityConfig struct {
}

func (*validateOpGetCloudFrontOriginAccessIdentityConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCloudFrontOriginAccessIdentityConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCloudFrontOriginAccessIdentityConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCloudFrontOriginAccessIdentityConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCloudFrontOriginAccessIdentity struct {
}

func (*validateOpGetCloudFrontOriginAccessIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCloudFrontOriginAccessIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCloudFrontOriginAccessIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCloudFrontOriginAccessIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetConnectionGroupByRoutingEndpoint struct {
}

func (*validateOpGetConnectionGroupByRoutingEndpoint) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetConnectionGroupByRoutingEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetConnectionGroupByRoutingEndpointInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetConnectionGroupByRoutingEndpointInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetConnectionGroup struct {
}

func (*validateOpGetConnectionGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetConnectionGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetConnectionGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetConnectionGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetContinuousDeploymentPolicyConfig struct {
}

func (*validateOpGetContinuousDeploymentPolicyConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetContinuousDeploymentPolicyConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetContinuousDeploymentPolicyConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetContinuousDeploymentPolicyConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetContinuousDeploymentPolicy struct {
}

func (*validateOpGetContinuousDeploymentPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetContinuousDeploymentPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetContinuousDeploymentPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetContinuousDeploymentPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDistributionConfig struct {
}

func (*validateOpGetDistributionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDistributionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDistributionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDistributionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDistribution struct {
}

func (*validateOpGetDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDistributionTenantByDomain struct {
}

func (*validateOpGetDistributionTenantByDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDistributionTenantByDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDistributionTenantByDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDistributionTenantByDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDistributionTenant struct {
}

func (*validateOpGetDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFieldLevelEncryptionConfig struct {
}

func (*validateOpGetFieldLevelEncryptionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFieldLevelEncryptionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFieldLevelEncryptionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFieldLevelEncryptionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFieldLevelEncryption struct {
}

func (*validateOpGetFieldLevelEncryption) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFieldLevelEncryption) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFieldLevelEncryptionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFieldLevelEncryptionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFieldLevelEncryptionProfileConfig struct {
}

func (*validateOpGetFieldLevelEncryptionProfileConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFieldLevelEncryptionProfileConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFieldLevelEncryptionProfileConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFieldLevelEncryptionProfileConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFieldLevelEncryptionProfile struct {
}

func (*validateOpGetFieldLevelEncryptionProfile) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFieldLevelEncryptionProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFieldLevelEncryptionProfileInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFieldLevelEncryptionProfileInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFunction struct {
}

func (*validateOpGetFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetInvalidationForDistributionTenant struct {
}

func (*validateOpGetInvalidationForDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetInvalidationForDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetInvalidationForDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetInvalidationForDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetInvalidation struct {
}

func (*validateOpGetInvalidation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetInvalidation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetInvalidationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetInvalidationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetKeyGroupConfig struct {
}

func (*validateOpGetKeyGroupConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetKeyGroupConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetKeyGroupConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetKeyGroupConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetKeyGroup struct {
}

func (*validateOpGetKeyGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetKeyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetKeyGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetKeyGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetManagedCertificateDetails struct {
}

func (*validateOpGetManagedCertificateDetails) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetManagedCertificateDetails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetManagedCertificateDetailsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetManagedCertificateDetailsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetMonitoringSubscription struct {
}

func (*validateOpGetMonitoringSubscription) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetMonitoringSubscription) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetMonitoringSubscriptionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetMonitoringSubscriptionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOriginAccessControlConfig struct {
}

func (*validateOpGetOriginAccessControlConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOriginAccessControlConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOriginAccessControlConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOriginAccessControlConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOriginAccessControl struct {
}

func (*validateOpGetOriginAccessControl) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOriginAccessControl) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOriginAccessControlInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOriginAccessControlInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOriginRequestPolicyConfig struct {
}

func (*validateOpGetOriginRequestPolicyConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOriginRequestPolicyConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOriginRequestPolicyConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOriginRequestPolicyConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOriginRequestPolicy struct {
}

func (*validateOpGetOriginRequestPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOriginRequestPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOriginRequestPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOriginRequestPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetPublicKeyConfig struct {
}

func (*validateOpGetPublicKeyConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetPublicKeyConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetPublicKeyConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetPublicKeyConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetPublicKey struct {
}

func (*validateOpGetPublicKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetPublicKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetPublicKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetPublicKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResponseHeadersPolicyConfig struct {
}

func (*validateOpGetResponseHeadersPolicyConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResponseHeadersPolicyConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResponseHeadersPolicyConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResponseHeadersPolicyConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResponseHeadersPolicy struct {
}

func (*validateOpGetResponseHeadersPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResponseHeadersPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResponseHeadersPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResponseHeadersPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetStreamingDistributionConfig struct {
}

func (*validateOpGetStreamingDistributionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetStreamingDistributionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetStreamingDistributionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetStreamingDistributionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetStreamingDistribution struct {
}

func (*validateOpGetStreamingDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetStreamingDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetStreamingDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetStreamingDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetVpcOrigin struct {
}

func (*validateOpGetVpcOrigin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetVpcOrigin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetVpcOriginInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetVpcOriginInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListConflictingAliases struct {
}

func (*validateOpListConflictingAliases) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListConflictingAliases) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListConflictingAliasesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListConflictingAliasesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByAnycastIpListId struct {
}

func (*validateOpListDistributionsByAnycastIpListId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByAnycastIpListId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByAnycastIpListIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByAnycastIpListIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByCachePolicyId struct {
}

func (*validateOpListDistributionsByCachePolicyId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByCachePolicyId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByCachePolicyIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByCachePolicyIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByConnectionMode struct {
}

func (*validateOpListDistributionsByConnectionMode) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByConnectionMode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByConnectionModeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByConnectionModeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByKeyGroup struct {
}

func (*validateOpListDistributionsByKeyGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByKeyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByKeyGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByKeyGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByOriginRequestPolicyId struct {
}

func (*validateOpListDistributionsByOriginRequestPolicyId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByOriginRequestPolicyId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByOriginRequestPolicyIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByOriginRequestPolicyIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByResponseHeadersPolicyId struct {
}

func (*validateOpListDistributionsByResponseHeadersPolicyId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByResponseHeadersPolicyId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByResponseHeadersPolicyIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByResponseHeadersPolicyIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByVpcOriginId struct {
}

func (*validateOpListDistributionsByVpcOriginId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByVpcOriginId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByVpcOriginIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByVpcOriginIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDistributionsByWebACLId struct {
}

func (*validateOpListDistributionsByWebACLId) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDistributionsByWebACLId) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDistributionsByWebACLIdInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDistributionsByWebACLIdInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDomainConflicts struct {
}

func (*validateOpListDomainConflicts) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDomainConflicts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDomainConflictsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDomainConflictsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListInvalidationsForDistributionTenant struct {
}

func (*validateOpListInvalidationsForDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListInvalidationsForDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListInvalidationsForDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListInvalidationsForDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListInvalidations struct {
}

func (*validateOpListInvalidations) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListInvalidations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListInvalidationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListInvalidationsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListTagsForResource struct {
}

func (*validateOpListTagsForResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListTagsForResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListTagsForResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPublishFunction struct {
}

func (*validateOpPublishFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPublishFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PublishFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPublishFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTestFunction struct {
}

func (*validateOpTestFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTestFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TestFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTestFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateCachePolicy struct {
}

func (*validateOpUpdateCachePolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateCachePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateCachePolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateCachePolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateCloudFrontOriginAccessIdentity struct {
}

func (*validateOpUpdateCloudFrontOriginAccessIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateCloudFrontOriginAccessIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateCloudFrontOriginAccessIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateCloudFrontOriginAccessIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateConnectionGroup struct {
}

func (*validateOpUpdateConnectionGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateConnectionGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateConnectionGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateConnectionGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateContinuousDeploymentPolicy struct {
}

func (*validateOpUpdateContinuousDeploymentPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateContinuousDeploymentPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateContinuousDeploymentPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateContinuousDeploymentPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDistribution struct {
}

func (*validateOpUpdateDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDistributionTenant struct {
}

func (*validateOpUpdateDistributionTenant) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDistributionTenant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDistributionTenantInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDistributionTenantInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDistributionWithStagingConfig struct {
}

func (*validateOpUpdateDistributionWithStagingConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDistributionWithStagingConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDistributionWithStagingConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDistributionWithStagingConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDomainAssociation struct {
}

func (*validateOpUpdateDomainAssociation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDomainAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDomainAssociationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDomainAssociationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateFieldLevelEncryptionConfig struct {
}

func (*validateOpUpdateFieldLevelEncryptionConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateFieldLevelEncryptionConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateFieldLevelEncryptionConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateFieldLevelEncryptionConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateFieldLevelEncryptionProfile struct {
}

func (*validateOpUpdateFieldLevelEncryptionProfile) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateFieldLevelEncryptionProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateFieldLevelEncryptionProfileInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateFieldLevelEncryptionProfileInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateFunction struct {
}

func (*validateOpUpdateFunction) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateFunction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateFunctionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateFunctionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateKeyGroup struct {
}

func (*validateOpUpdateKeyGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateKeyGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateKeyGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateKeyGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateKeyValueStore struct {
}

func (*validateOpUpdateKeyValueStore) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateKeyValueStore) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateKeyValueStoreInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateKeyValueStoreInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateOriginAccessControl struct {
}

func (*validateOpUpdateOriginAccessControl) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateOriginAccessControl) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateOriginAccessControlInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateOriginAccessControlInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateOriginRequestPolicy struct {
}

func (*validateOpUpdateOriginRequestPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateOriginRequestPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateOriginRequestPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateOriginRequestPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdatePublicKey struct {
}

func (*validateOpUpdatePublicKey) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdatePublicKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdatePublicKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdatePublicKeyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRealtimeLogConfig struct {
}

func (*validateOpUpdateRealtimeLogConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRealtimeLogConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRealtimeLogConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRealtimeLogConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateResponseHeadersPolicy struct {
}

func (*validateOpUpdateResponseHeadersPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateResponseHeadersPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateResponseHeadersPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateResponseHeadersPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateStreamingDistribution struct {
}

func (*validateOpUpdateStreamingDistribution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateStreamingDistribution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateStreamingDistributionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateStreamingDistributionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateVpcOrigin struct {
}

func (*validateOpUpdateVpcOrigin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateVpcOrigin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateVpcOriginInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateVpcOriginInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyDnsConfiguration struct {
}

func (*validateOpVerifyDnsConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyDnsConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyDnsConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyDnsConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpAssociateAliasValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateAlias{}, middleware.After)
}

func addOpAssociateDistributionTenantWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateDistributionTenantWebACL{}, middleware.After)
}

func addOpAssociateDistributionWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateDistributionWebACL{}, middleware.After)
}

func addOpCopyDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyDistribution{}, middleware.After)
}

func addOpCreateAnycastIpListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateAnycastIpList{}, middleware.After)
}

func addOpCreateCachePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCachePolicy{}, middleware.After)
}

func addOpCreateCloudFrontOriginAccessIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCloudFrontOriginAccessIdentity{}, middleware.After)
}

func addOpCreateConnectionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateConnectionGroup{}, middleware.After)
}

func addOpCreateContinuousDeploymentPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateContinuousDeploymentPolicy{}, middleware.After)
}

func addOpCreateDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDistribution{}, middleware.After)
}

func addOpCreateDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDistributionTenant{}, middleware.After)
}

func addOpCreateDistributionWithTagsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDistributionWithTags{}, middleware.After)
}

func addOpCreateFieldLevelEncryptionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFieldLevelEncryptionConfig{}, middleware.After)
}

func addOpCreateFieldLevelEncryptionProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFieldLevelEncryptionProfile{}, middleware.After)
}

func addOpCreateFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFunction{}, middleware.After)
}

func addOpCreateInvalidationForDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInvalidationForDistributionTenant{}, middleware.After)
}

func addOpCreateInvalidationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInvalidation{}, middleware.After)
}

func addOpCreateKeyGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateKeyGroup{}, middleware.After)
}

func addOpCreateKeyValueStoreValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateKeyValueStore{}, middleware.After)
}

func addOpCreateMonitoringSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateMonitoringSubscription{}, middleware.After)
}

func addOpCreateOriginAccessControlValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateOriginAccessControl{}, middleware.After)
}

func addOpCreateOriginRequestPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateOriginRequestPolicy{}, middleware.After)
}

func addOpCreatePublicKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreatePublicKey{}, middleware.After)
}

func addOpCreateRealtimeLogConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRealtimeLogConfig{}, middleware.After)
}

func addOpCreateResponseHeadersPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateResponseHeadersPolicy{}, middleware.After)
}

func addOpCreateStreamingDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateStreamingDistribution{}, middleware.After)
}

func addOpCreateStreamingDistributionWithTagsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateStreamingDistributionWithTags{}, middleware.After)
}

func addOpCreateVpcOriginValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcOrigin{}, middleware.After)
}

func addOpDeleteAnycastIpListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteAnycastIpList{}, middleware.After)
}

func addOpDeleteCachePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCachePolicy{}, middleware.After)
}

func addOpDeleteCloudFrontOriginAccessIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCloudFrontOriginAccessIdentity{}, middleware.After)
}

func addOpDeleteConnectionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConnectionGroup{}, middleware.After)
}

func addOpDeleteContinuousDeploymentPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteContinuousDeploymentPolicy{}, middleware.After)
}

func addOpDeleteDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDistribution{}, middleware.After)
}

func addOpDeleteDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDistributionTenant{}, middleware.After)
}

func addOpDeleteFieldLevelEncryptionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFieldLevelEncryptionConfig{}, middleware.After)
}

func addOpDeleteFieldLevelEncryptionProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFieldLevelEncryptionProfile{}, middleware.After)
}

func addOpDeleteFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFunction{}, middleware.After)
}

func addOpDeleteKeyGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteKeyGroup{}, middleware.After)
}

func addOpDeleteKeyValueStoreValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteKeyValueStore{}, middleware.After)
}

func addOpDeleteMonitoringSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteMonitoringSubscription{}, middleware.After)
}

func addOpDeleteOriginAccessControlValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteOriginAccessControl{}, middleware.After)
}

func addOpDeleteOriginRequestPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteOriginRequestPolicy{}, middleware.After)
}

func addOpDeletePublicKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeletePublicKey{}, middleware.After)
}

func addOpDeleteResponseHeadersPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteResponseHeadersPolicy{}, middleware.After)
}

func addOpDeleteStreamingDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteStreamingDistribution{}, middleware.After)
}

func addOpDeleteVpcOriginValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcOrigin{}, middleware.After)
}

func addOpDescribeFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeFunction{}, middleware.After)
}

func addOpDescribeKeyValueStoreValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeKeyValueStore{}, middleware.After)
}

func addOpDisassociateDistributionTenantWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateDistributionTenantWebACL{}, middleware.After)
}

func addOpDisassociateDistributionWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateDistributionWebACL{}, middleware.After)
}

func addOpGetAnycastIpListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAnycastIpList{}, middleware.After)
}

func addOpGetCachePolicyConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCachePolicyConfig{}, middleware.After)
}

func addOpGetCachePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCachePolicy{}, middleware.After)
}

func addOpGetCloudFrontOriginAccessIdentityConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCloudFrontOriginAccessIdentityConfig{}, middleware.After)
}

func addOpGetCloudFrontOriginAccessIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCloudFrontOriginAccessIdentity{}, middleware.After)
}

func addOpGetConnectionGroupByRoutingEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConnectionGroupByRoutingEndpoint{}, middleware.After)
}

func addOpGetConnectionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConnectionGroup{}, middleware.After)
}

func addOpGetContinuousDeploymentPolicyConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetContinuousDeploymentPolicyConfig{}, middleware.After)
}

func addOpGetContinuousDeploymentPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetContinuousDeploymentPolicy{}, middleware.After)
}

func addOpGetDistributionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDistributionConfig{}, middleware.After)
}

func addOpGetDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDistribution{}, middleware.After)
}

func addOpGetDistributionTenantByDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDistributionTenantByDomain{}, middleware.After)
}

func addOpGetDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDistributionTenant{}, middleware.After)
}

func addOpGetFieldLevelEncryptionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFieldLevelEncryptionConfig{}, middleware.After)
}

func addOpGetFieldLevelEncryptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFieldLevelEncryption{}, middleware.After)
}

func addOpGetFieldLevelEncryptionProfileConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFieldLevelEncryptionProfileConfig{}, middleware.After)
}

func addOpGetFieldLevelEncryptionProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFieldLevelEncryptionProfile{}, middleware.After)
}

func addOpGetFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFunction{}, middleware.After)
}

func addOpGetInvalidationForDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetInvalidationForDistributionTenant{}, middleware.After)
}

func addOpGetInvalidationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetInvalidation{}, middleware.After)
}

func addOpGetKeyGroupConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetKeyGroupConfig{}, middleware.After)
}

func addOpGetKeyGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetKeyGroup{}, middleware.After)
}

func addOpGetManagedCertificateDetailsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetManagedCertificateDetails{}, middleware.After)
}

func addOpGetMonitoringSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetMonitoringSubscription{}, middleware.After)
}

func addOpGetOriginAccessControlConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOriginAccessControlConfig{}, middleware.After)
}

func addOpGetOriginAccessControlValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOriginAccessControl{}, middleware.After)
}

func addOpGetOriginRequestPolicyConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOriginRequestPolicyConfig{}, middleware.After)
}

func addOpGetOriginRequestPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOriginRequestPolicy{}, middleware.After)
}

func addOpGetPublicKeyConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetPublicKeyConfig{}, middleware.After)
}

func addOpGetPublicKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetPublicKey{}, middleware.After)
}

func addOpGetResponseHeadersPolicyConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResponseHeadersPolicyConfig{}, middleware.After)
}

func addOpGetResponseHeadersPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResponseHeadersPolicy{}, middleware.After)
}

func addOpGetStreamingDistributionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetStreamingDistributionConfig{}, middleware.After)
}

func addOpGetStreamingDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetStreamingDistribution{}, middleware.After)
}

func addOpGetVpcOriginValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVpcOrigin{}, middleware.After)
}

func addOpListConflictingAliasesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListConflictingAliases{}, middleware.After)
}

func addOpListDistributionsByAnycastIpListIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByAnycastIpListId{}, middleware.After)
}

func addOpListDistributionsByCachePolicyIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByCachePolicyId{}, middleware.After)
}

func addOpListDistributionsByConnectionModeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByConnectionMode{}, middleware.After)
}

func addOpListDistributionsByKeyGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByKeyGroup{}, middleware.After)
}

func addOpListDistributionsByOriginRequestPolicyIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByOriginRequestPolicyId{}, middleware.After)
}

func addOpListDistributionsByResponseHeadersPolicyIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByResponseHeadersPolicyId{}, middleware.After)
}

func addOpListDistributionsByVpcOriginIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByVpcOriginId{}, middleware.After)
}

func addOpListDistributionsByWebACLIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDistributionsByWebACLId{}, middleware.After)
}

func addOpListDomainConflictsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDomainConflicts{}, middleware.After)
}

func addOpListInvalidationsForDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListInvalidationsForDistributionTenant{}, middleware.After)
}

func addOpListInvalidationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListInvalidations{}, middleware.After)
}

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}

func addOpPublishFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPublishFunction{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpTestFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTestFunction{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func addOpUpdateCachePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCachePolicy{}, middleware.After)
}

func addOpUpdateCloudFrontOriginAccessIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCloudFrontOriginAccessIdentity{}, middleware.After)
}

func addOpUpdateConnectionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConnectionGroup{}, middleware.After)
}

func addOpUpdateContinuousDeploymentPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateContinuousDeploymentPolicy{}, middleware.After)
}

func addOpUpdateDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDistribution{}, middleware.After)
}

func addOpUpdateDistributionTenantValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDistributionTenant{}, middleware.After)
}

func addOpUpdateDistributionWithStagingConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDistributionWithStagingConfig{}, middleware.After)
}

func addOpUpdateDomainAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDomainAssociation{}, middleware.After)
}

func addOpUpdateFieldLevelEncryptionConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFieldLevelEncryptionConfig{}, middleware.After)
}

func addOpUpdateFieldLevelEncryptionProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFieldLevelEncryptionProfile{}, middleware.After)
}

func addOpUpdateFunctionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFunction{}, middleware.After)
}

func addOpUpdateKeyGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateKeyGroup{}, middleware.After)
}

func addOpUpdateKeyValueStoreValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateKeyValueStore{}, middleware.After)
}

func addOpUpdateOriginAccessControlValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateOriginAccessControl{}, middleware.After)
}

func addOpUpdateOriginRequestPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateOriginRequestPolicy{}, middleware.After)
}

func addOpUpdatePublicKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdatePublicKey{}, middleware.After)
}

func addOpUpdateRealtimeLogConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRealtimeLogConfig{}, middleware.After)
}

func addOpUpdateResponseHeadersPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateResponseHeadersPolicy{}, middleware.After)
}

func addOpUpdateStreamingDistributionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateStreamingDistribution{}, middleware.After)
}

func addOpUpdateVpcOriginValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateVpcOrigin{}, middleware.After)
}

func addOpVerifyDnsConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyDnsConfiguration{}, middleware.After)
}

func validateAliases(v *types.Aliases) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Aliases"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAllowedMethods(v *types.AllowedMethods) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllowedMethods"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if v.CachedMethods != nil {
		if err := validateCachedMethods(v.CachedMethods); err != nil {
			invalidParams.AddNested("CachedMethods", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCacheBehavior(v *types.CacheBehavior) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CacheBehavior"}
	if v.PathPattern == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PathPattern"))
	}
	if v.TargetOriginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetOriginId"))
	}
	if v.TrustedSigners != nil {
		if err := validateTrustedSigners(v.TrustedSigners); err != nil {
			invalidParams.AddNested("TrustedSigners", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrustedKeyGroups != nil {
		if err := validateTrustedKeyGroups(v.TrustedKeyGroups); err != nil {
			invalidParams.AddNested("TrustedKeyGroups", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ViewerProtocolPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ViewerProtocolPolicy"))
	}
	if v.AllowedMethods != nil {
		if err := validateAllowedMethods(v.AllowedMethods); err != nil {
			invalidParams.AddNested("AllowedMethods", err.(smithy.InvalidParamsError))
		}
	}
	if v.LambdaFunctionAssociations != nil {
		if err := validateLambdaFunctionAssociations(v.LambdaFunctionAssociations); err != nil {
			invalidParams.AddNested("LambdaFunctionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunctionAssociations != nil {
		if err := validateFunctionAssociations(v.FunctionAssociations); err != nil {
			invalidParams.AddNested("FunctionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if v.GrpcConfig != nil {
		if err := validateGrpcConfig(v.GrpcConfig); err != nil {
			invalidParams.AddNested("GrpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ForwardedValues != nil {
		if err := validateForwardedValues(v.ForwardedValues); err != nil {
			invalidParams.AddNested("ForwardedValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCacheBehaviorList(v []types.CacheBehavior) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CacheBehaviorList"}
	for i := range v {
		if err := validateCacheBehavior(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCacheBehaviors(v *types.CacheBehaviors) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CacheBehaviors"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateCacheBehaviorList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCachedMethods(v *types.CachedMethods) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CachedMethods"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCachePolicyConfig(v *types.CachePolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CachePolicyConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MinTTL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinTTL"))
	}
	if v.ParametersInCacheKeyAndForwardedToOrigin != nil {
		if err := validateParametersInCacheKeyAndForwardedToOrigin(v.ParametersInCacheKeyAndForwardedToOrigin); err != nil {
			invalidParams.AddNested("ParametersInCacheKeyAndForwardedToOrigin", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCachePolicyCookiesConfig(v *types.CachePolicyCookiesConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CachePolicyCookiesConfig"}
	if len(v.CookieBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CookieBehavior"))
	}
	if v.Cookies != nil {
		if err := validateCookieNames(v.Cookies); err != nil {
			invalidParams.AddNested("Cookies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCachePolicyHeadersConfig(v *types.CachePolicyHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CachePolicyHeadersConfig"}
	if len(v.HeaderBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderBehavior"))
	}
	if v.Headers != nil {
		if err := validateHeaders(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCachePolicyQueryStringsConfig(v *types.CachePolicyQueryStringsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CachePolicyQueryStringsConfig"}
	if len(v.QueryStringBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QueryStringBehavior"))
	}
	if v.QueryStrings != nil {
		if err := validateQueryStringNames(v.QueryStrings); err != nil {
			invalidParams.AddNested("QueryStrings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCertificate(v *types.Certificate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Certificate"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudFrontOriginAccessIdentityConfig(v *types.CloudFrontOriginAccessIdentityConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudFrontOriginAccessIdentityConfig"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentTypeProfile(v *types.ContentTypeProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentTypeProfile"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.ContentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentTypeProfileConfig(v *types.ContentTypeProfileConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentTypeProfileConfig"}
	if v.ForwardWhenContentTypeIsUnknown == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForwardWhenContentTypeIsUnknown"))
	}
	if v.ContentTypeProfiles != nil {
		if err := validateContentTypeProfiles(v.ContentTypeProfiles); err != nil {
			invalidParams.AddNested("ContentTypeProfiles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentTypeProfileList(v []types.ContentTypeProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentTypeProfileList"}
	for i := range v {
		if err := validateContentTypeProfile(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentTypeProfiles(v *types.ContentTypeProfiles) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentTypeProfiles"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateContentTypeProfileList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContinuousDeploymentPolicyConfig(v *types.ContinuousDeploymentPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContinuousDeploymentPolicyConfig"}
	if v.StagingDistributionDnsNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StagingDistributionDnsNames"))
	} else if v.StagingDistributionDnsNames != nil {
		if err := validateStagingDistributionDnsNames(v.StagingDistributionDnsNames); err != nil {
			invalidParams.AddNested("StagingDistributionDnsNames", err.(smithy.InvalidParamsError))
		}
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.TrafficConfig != nil {
		if err := validateTrafficConfig(v.TrafficConfig); err != nil {
			invalidParams.AddNested("TrafficConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContinuousDeploymentSingleHeaderConfig(v *types.ContinuousDeploymentSingleHeaderConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContinuousDeploymentSingleHeaderConfig"}
	if v.Header == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Header"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContinuousDeploymentSingleWeightConfig(v *types.ContinuousDeploymentSingleWeightConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContinuousDeploymentSingleWeightConfig"}
	if v.Weight == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Weight"))
	}
	if v.SessionStickinessConfig != nil {
		if err := validateSessionStickinessConfig(v.SessionStickinessConfig); err != nil {
			invalidParams.AddNested("SessionStickinessConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCookieNames(v *types.CookieNames) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CookieNames"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCookiePreference(v *types.CookiePreference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CookiePreference"}
	if len(v.Forward) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Forward"))
	}
	if v.WhitelistedNames != nil {
		if err := validateCookieNames(v.WhitelistedNames); err != nil {
			invalidParams.AddNested("WhitelistedNames", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomErrorResponse(v *types.CustomErrorResponse) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomErrorResponse"}
	if v.ErrorCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ErrorCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomErrorResponseList(v []types.CustomErrorResponse) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomErrorResponseList"}
	for i := range v {
		if err := validateCustomErrorResponse(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomErrorResponses(v *types.CustomErrorResponses) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomErrorResponses"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateCustomErrorResponseList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomHeaders(v *types.CustomHeaders) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomHeaders"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateOriginCustomHeadersList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomizations(v *types.Customizations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Customizations"}
	if v.WebAcl != nil {
		if err := validateWebAclCustomization(v.WebAcl); err != nil {
			invalidParams.AddNested("WebAcl", err.(smithy.InvalidParamsError))
		}
	}
	if v.Certificate != nil {
		if err := validateCertificate(v.Certificate); err != nil {
			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
		}
	}
	if v.GeoRestrictions != nil {
		if err := validateGeoRestrictionCustomization(v.GeoRestrictions); err != nil {
			invalidParams.AddNested("GeoRestrictions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomOriginConfig(v *types.CustomOriginConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomOriginConfig"}
	if v.HTTPPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HTTPPort"))
	}
	if v.HTTPSPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HTTPSPort"))
	}
	if len(v.OriginProtocolPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OriginProtocolPolicy"))
	}
	if v.OriginSslProtocols != nil {
		if err := validateOriginSslProtocols(v.OriginSslProtocols); err != nil {
			invalidParams.AddNested("OriginSslProtocols", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultCacheBehavior(v *types.DefaultCacheBehavior) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultCacheBehavior"}
	if v.TargetOriginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetOriginId"))
	}
	if v.TrustedSigners != nil {
		if err := validateTrustedSigners(v.TrustedSigners); err != nil {
			invalidParams.AddNested("TrustedSigners", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrustedKeyGroups != nil {
		if err := validateTrustedKeyGroups(v.TrustedKeyGroups); err != nil {
			invalidParams.AddNested("TrustedKeyGroups", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ViewerProtocolPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ViewerProtocolPolicy"))
	}
	if v.AllowedMethods != nil {
		if err := validateAllowedMethods(v.AllowedMethods); err != nil {
			invalidParams.AddNested("AllowedMethods", err.(smithy.InvalidParamsError))
		}
	}
	if v.LambdaFunctionAssociations != nil {
		if err := validateLambdaFunctionAssociations(v.LambdaFunctionAssociations); err != nil {
			invalidParams.AddNested("LambdaFunctionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunctionAssociations != nil {
		if err := validateFunctionAssociations(v.FunctionAssociations); err != nil {
			invalidParams.AddNested("FunctionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if v.GrpcConfig != nil {
		if err := validateGrpcConfig(v.GrpcConfig); err != nil {
			invalidParams.AddNested("GrpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ForwardedValues != nil {
		if err := validateForwardedValues(v.ForwardedValues); err != nil {
			invalidParams.AddNested("ForwardedValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDistributionConfig(v *types.DistributionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DistributionConfig"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.Aliases != nil {
		if err := validateAliases(v.Aliases); err != nil {
			invalidParams.AddNested("Aliases", err.(smithy.InvalidParamsError))
		}
	}
	if v.Origins == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Origins"))
	} else if v.Origins != nil {
		if err := validateOrigins(v.Origins); err != nil {
			invalidParams.AddNested("Origins", err.(smithy.InvalidParamsError))
		}
	}
	if v.OriginGroups != nil {
		if err := validateOriginGroups(v.OriginGroups); err != nil {
			invalidParams.AddNested("OriginGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultCacheBehavior == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultCacheBehavior"))
	} else if v.DefaultCacheBehavior != nil {
		if err := validateDefaultCacheBehavior(v.DefaultCacheBehavior); err != nil {
			invalidParams.AddNested("DefaultCacheBehavior", err.(smithy.InvalidParamsError))
		}
	}
	if v.CacheBehaviors != nil {
		if err := validateCacheBehaviors(v.CacheBehaviors); err != nil {
			invalidParams.AddNested("CacheBehaviors", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomErrorResponses != nil {
		if err := validateCustomErrorResponses(v.CustomErrorResponses); err != nil {
			invalidParams.AddNested("CustomErrorResponses", err.(smithy.InvalidParamsError))
		}
	}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.Restrictions != nil {
		if err := validateRestrictions(v.Restrictions); err != nil {
			invalidParams.AddNested("Restrictions", err.(smithy.InvalidParamsError))
		}
	}
	if v.TenantConfig != nil {
		if err := validateTenantConfig(v.TenantConfig); err != nil {
			invalidParams.AddNested("TenantConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDistributionConfigWithTags(v *types.DistributionConfigWithTags) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DistributionConfigWithTags"}
	if v.DistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionConfig"))
	} else if v.DistributionConfig != nil {
		if err := validateDistributionConfig(v.DistributionConfig); err != nil {
			invalidParams.AddNested("DistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDomainItem(v *types.DomainItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DomainItem"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDomainList(v []types.DomainItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DomainList"}
	for i := range v {
		if err := validateDomainItem(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEncryptionEntities(v *types.EncryptionEntities) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncryptionEntities"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateEncryptionEntityList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEncryptionEntity(v *types.EncryptionEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncryptionEntity"}
	if v.PublicKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyId"))
	}
	if v.ProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderId"))
	}
	if v.FieldPatterns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldPatterns"))
	} else if v.FieldPatterns != nil {
		if err := validateFieldPatterns(v.FieldPatterns); err != nil {
			invalidParams.AddNested("FieldPatterns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEncryptionEntityList(v []types.EncryptionEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncryptionEntityList"}
	for i := range v {
		if err := validateEncryptionEntity(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEndPoint(v *types.EndPoint) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EndPoint"}
	if v.StreamType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamType"))
	}
	if v.KinesisStreamConfig != nil {
		if err := validateKinesisStreamConfig(v.KinesisStreamConfig); err != nil {
			invalidParams.AddNested("KinesisStreamConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEndPointList(v []types.EndPoint) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EndPointList"}
	for i := range v {
		if err := validateEndPoint(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldLevelEncryptionConfig(v *types.FieldLevelEncryptionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldLevelEncryptionConfig"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.QueryArgProfileConfig != nil {
		if err := validateQueryArgProfileConfig(v.QueryArgProfileConfig); err != nil {
			invalidParams.AddNested("QueryArgProfileConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentTypeProfileConfig != nil {
		if err := validateContentTypeProfileConfig(v.ContentTypeProfileConfig); err != nil {
			invalidParams.AddNested("ContentTypeProfileConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldLevelEncryptionProfileConfig(v *types.FieldLevelEncryptionProfileConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldLevelEncryptionProfileConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.EncryptionEntities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionEntities"))
	} else if v.EncryptionEntities != nil {
		if err := validateEncryptionEntities(v.EncryptionEntities); err != nil {
			invalidParams.AddNested("EncryptionEntities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldPatterns(v *types.FieldPatterns) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldPatterns"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateForwardedValues(v *types.ForwardedValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForwardedValues"}
	if v.QueryString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryString"))
	}
	if v.Cookies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cookies"))
	} else if v.Cookies != nil {
		if err := validateCookiePreference(v.Cookies); err != nil {
			invalidParams.AddNested("Cookies", err.(smithy.InvalidParamsError))
		}
	}
	if v.Headers != nil {
		if err := validateHeaders(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryStringCacheKeys != nil {
		if err := validateQueryStringCacheKeys(v.QueryStringCacheKeys); err != nil {
			invalidParams.AddNested("QueryStringCacheKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunctionAssociation(v *types.FunctionAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunctionAssociation"}
	if v.FunctionARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionARN"))
	}
	if len(v.EventType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunctionAssociationList(v []types.FunctionAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunctionAssociationList"}
	for i := range v {
		if err := validateFunctionAssociation(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunctionAssociations(v *types.FunctionAssociations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunctionAssociations"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateFunctionAssociationList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunctionConfig(v *types.FunctionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunctionConfig"}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if len(v.Runtime) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Runtime"))
	}
	if v.KeyValueStoreAssociations != nil {
		if err := validateKeyValueStoreAssociations(v.KeyValueStoreAssociations); err != nil {
			invalidParams.AddNested("KeyValueStoreAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoRestriction(v *types.GeoRestriction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoRestriction"}
	if len(v.RestrictionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RestrictionType"))
	}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoRestrictionCustomization(v *types.GeoRestrictionCustomization) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoRestrictionCustomization"}
	if len(v.RestrictionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RestrictionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGrpcConfig(v *types.GrpcConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrpcConfig"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHeaders(v *types.Headers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Headers"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImportSource(v *types.ImportSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportSource"}
	if len(v.SourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
	}
	if v.SourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInvalidationBatch(v *types.InvalidationBatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvalidationBatch"}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	} else if v.Paths != nil {
		if err := validatePaths(v.Paths); err != nil {
			invalidParams.AddNested("Paths", err.(smithy.InvalidParamsError))
		}
	}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKeyGroupConfig(v *types.KeyGroupConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyGroupConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKeyValueStoreAssociation(v *types.KeyValueStoreAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyValueStoreAssociation"}
	if v.KeyValueStoreARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyValueStoreARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKeyValueStoreAssociationList(v []types.KeyValueStoreAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyValueStoreAssociationList"}
	for i := range v {
		if err := validateKeyValueStoreAssociation(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKeyValueStoreAssociations(v *types.KeyValueStoreAssociations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyValueStoreAssociations"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateKeyValueStoreAssociationList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKinesisStreamConfig(v *types.KinesisStreamConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisStreamConfig"}
	if v.RoleARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleARN"))
	}
	if v.StreamARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLambdaFunctionAssociation(v *types.LambdaFunctionAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaFunctionAssociation"}
	if v.LambdaFunctionARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaFunctionARN"))
	}
	if len(v.EventType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLambdaFunctionAssociationList(v []types.LambdaFunctionAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaFunctionAssociationList"}
	for i := range v {
		if err := validateLambdaFunctionAssociation(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLambdaFunctionAssociations(v *types.LambdaFunctionAssociations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaFunctionAssociations"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateLambdaFunctionAssociationList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateManagedCertificateRequest(v *types.ManagedCertificateRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagedCertificateRequest"}
	if len(v.ValidationTokenHost) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationTokenHost"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMonitoringSubscription(v *types.MonitoringSubscription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoringSubscription"}
	if v.RealtimeMetricsSubscriptionConfig != nil {
		if err := validateRealtimeMetricsSubscriptionConfig(v.RealtimeMetricsSubscriptionConfig); err != nil {
			invalidParams.AddNested("RealtimeMetricsSubscriptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrigin(v *types.Origin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Origin"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.CustomHeaders != nil {
		if err := validateCustomHeaders(v.CustomHeaders); err != nil {
			invalidParams.AddNested("CustomHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3OriginConfig != nil {
		if err := validateS3OriginConfig(v.S3OriginConfig); err != nil {
			invalidParams.AddNested("S3OriginConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomOriginConfig != nil {
		if err := validateCustomOriginConfig(v.CustomOriginConfig); err != nil {
			invalidParams.AddNested("CustomOriginConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcOriginConfig != nil {
		if err := validateVpcOriginConfig(v.VpcOriginConfig); err != nil {
			invalidParams.AddNested("VpcOriginConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OriginShield != nil {
		if err := validateOriginShield(v.OriginShield); err != nil {
			invalidParams.AddNested("OriginShield", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginAccessControlConfig(v *types.OriginAccessControlConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginAccessControlConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.SigningProtocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SigningProtocol"))
	}
	if len(v.SigningBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SigningBehavior"))
	}
	if len(v.OriginAccessControlOriginType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccessControlOriginType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginCustomHeader(v *types.OriginCustomHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginCustomHeader"}
	if v.HeaderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderName"))
	}
	if v.HeaderValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginCustomHeadersList(v []types.OriginCustomHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginCustomHeadersList"}
	for i := range v {
		if err := validateOriginCustomHeader(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroup(v *types.OriginGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroup"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.FailoverCriteria == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailoverCriteria"))
	} else if v.FailoverCriteria != nil {
		if err := validateOriginGroupFailoverCriteria(v.FailoverCriteria); err != nil {
			invalidParams.AddNested("FailoverCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if v.Members == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Members"))
	} else if v.Members != nil {
		if err := validateOriginGroupMembers(v.Members); err != nil {
			invalidParams.AddNested("Members", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroupFailoverCriteria(v *types.OriginGroupFailoverCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroupFailoverCriteria"}
	if v.StatusCodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCodes"))
	} else if v.StatusCodes != nil {
		if err := validateStatusCodes(v.StatusCodes); err != nil {
			invalidParams.AddNested("StatusCodes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroupList(v []types.OriginGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroupList"}
	for i := range v {
		if err := validateOriginGroup(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroupMember(v *types.OriginGroupMember) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroupMember"}
	if v.OriginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroupMemberList(v []types.OriginGroupMember) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroupMemberList"}
	for i := range v {
		if err := validateOriginGroupMember(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroupMembers(v *types.OriginGroupMembers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroupMembers"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	} else if v.Items != nil {
		if err := validateOriginGroupMemberList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginGroups(v *types.OriginGroups) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginGroups"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateOriginGroupList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginList(v []types.Origin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginList"}
	for i := range v {
		if err := validateOrigin(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginRequestPolicyConfig(v *types.OriginRequestPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginRequestPolicyConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.HeadersConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeadersConfig"))
	} else if v.HeadersConfig != nil {
		if err := validateOriginRequestPolicyHeadersConfig(v.HeadersConfig); err != nil {
			invalidParams.AddNested("HeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CookiesConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CookiesConfig"))
	} else if v.CookiesConfig != nil {
		if err := validateOriginRequestPolicyCookiesConfig(v.CookiesConfig); err != nil {
			invalidParams.AddNested("CookiesConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryStringsConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryStringsConfig"))
	} else if v.QueryStringsConfig != nil {
		if err := validateOriginRequestPolicyQueryStringsConfig(v.QueryStringsConfig); err != nil {
			invalidParams.AddNested("QueryStringsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginRequestPolicyCookiesConfig(v *types.OriginRequestPolicyCookiesConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginRequestPolicyCookiesConfig"}
	if len(v.CookieBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CookieBehavior"))
	}
	if v.Cookies != nil {
		if err := validateCookieNames(v.Cookies); err != nil {
			invalidParams.AddNested("Cookies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginRequestPolicyHeadersConfig(v *types.OriginRequestPolicyHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginRequestPolicyHeadersConfig"}
	if len(v.HeaderBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderBehavior"))
	}
	if v.Headers != nil {
		if err := validateHeaders(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginRequestPolicyQueryStringsConfig(v *types.OriginRequestPolicyQueryStringsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginRequestPolicyQueryStringsConfig"}
	if len(v.QueryStringBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QueryStringBehavior"))
	}
	if v.QueryStrings != nil {
		if err := validateQueryStringNames(v.QueryStrings); err != nil {
			invalidParams.AddNested("QueryStrings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrigins(v *types.Origins) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Origins"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	} else if v.Items != nil {
		if err := validateOriginList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginShield(v *types.OriginShield) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginShield"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOriginSslProtocols(v *types.OriginSslProtocols) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OriginSslProtocols"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameter(v *types.Parameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Parameter"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterDefinition(v *types.ParameterDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDefinition"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	} else if v.Definition != nil {
		if err := validateParameterDefinitionSchema(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterDefinitions(v []types.ParameterDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDefinitions"}
	for i := range v {
		if err := validateParameterDefinition(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterDefinitionSchema(v *types.ParameterDefinitionSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDefinitionSchema"}
	if v.StringSchema != nil {
		if err := validateStringSchemaConfig(v.StringSchema); err != nil {
			invalidParams.AddNested("StringSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameters(v []types.Parameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Parameters"}
	for i := range v {
		if err := validateParameter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParametersInCacheKeyAndForwardedToOrigin(v *types.ParametersInCacheKeyAndForwardedToOrigin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParametersInCacheKeyAndForwardedToOrigin"}
	if v.EnableAcceptEncodingGzip == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnableAcceptEncodingGzip"))
	}
	if v.HeadersConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeadersConfig"))
	} else if v.HeadersConfig != nil {
		if err := validateCachePolicyHeadersConfig(v.HeadersConfig); err != nil {
			invalidParams.AddNested("HeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CookiesConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CookiesConfig"))
	} else if v.CookiesConfig != nil {
		if err := validateCachePolicyCookiesConfig(v.CookiesConfig); err != nil {
			invalidParams.AddNested("CookiesConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryStringsConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryStringsConfig"))
	} else if v.QueryStringsConfig != nil {
		if err := validateCachePolicyQueryStringsConfig(v.QueryStringsConfig); err != nil {
			invalidParams.AddNested("QueryStringsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePaths(v *types.Paths) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Paths"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePublicKeyConfig(v *types.PublicKeyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PublicKeyConfig"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EncodedKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EncodedKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryArgProfile(v *types.QueryArgProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryArgProfile"}
	if v.QueryArg == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryArg"))
	}
	if v.ProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryArgProfileConfig(v *types.QueryArgProfileConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryArgProfileConfig"}
	if v.ForwardWhenQueryArgProfileIsUnknown == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForwardWhenQueryArgProfileIsUnknown"))
	}
	if v.QueryArgProfiles != nil {
		if err := validateQueryArgProfiles(v.QueryArgProfiles); err != nil {
			invalidParams.AddNested("QueryArgProfiles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryArgProfileList(v []types.QueryArgProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryArgProfileList"}
	for i := range v {
		if err := validateQueryArgProfile(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryArgProfiles(v *types.QueryArgProfiles) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryArgProfiles"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateQueryArgProfileList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryStringCacheKeys(v *types.QueryStringCacheKeys) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryStringCacheKeys"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryStringNames(v *types.QueryStringNames) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryStringNames"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRealtimeMetricsSubscriptionConfig(v *types.RealtimeMetricsSubscriptionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RealtimeMetricsSubscriptionConfig"}
	if len(v.RealtimeMetricsSubscriptionStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RealtimeMetricsSubscriptionStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyAccessControlAllowHeaders(v *types.ResponseHeadersPolicyAccessControlAllowHeaders) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyAccessControlAllowHeaders"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyAccessControlAllowMethods(v *types.ResponseHeadersPolicyAccessControlAllowMethods) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyAccessControlAllowMethods"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyAccessControlAllowOrigins(v *types.ResponseHeadersPolicyAccessControlAllowOrigins) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyAccessControlAllowOrigins"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyAccessControlExposeHeaders(v *types.ResponseHeadersPolicyAccessControlExposeHeaders) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyAccessControlExposeHeaders"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyConfig(v *types.ResponseHeadersPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.CorsConfig != nil {
		if err := validateResponseHeadersPolicyCorsConfig(v.CorsConfig); err != nil {
			invalidParams.AddNested("CorsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecurityHeadersConfig != nil {
		if err := validateResponseHeadersPolicySecurityHeadersConfig(v.SecurityHeadersConfig); err != nil {
			invalidParams.AddNested("SecurityHeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServerTimingHeadersConfig != nil {
		if err := validateResponseHeadersPolicyServerTimingHeadersConfig(v.ServerTimingHeadersConfig); err != nil {
			invalidParams.AddNested("ServerTimingHeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomHeadersConfig != nil {
		if err := validateResponseHeadersPolicyCustomHeadersConfig(v.CustomHeadersConfig); err != nil {
			invalidParams.AddNested("CustomHeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoveHeadersConfig != nil {
		if err := validateResponseHeadersPolicyRemoveHeadersConfig(v.RemoveHeadersConfig); err != nil {
			invalidParams.AddNested("RemoveHeadersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyContentSecurityPolicy(v *types.ResponseHeadersPolicyContentSecurityPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyContentSecurityPolicy"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if v.ContentSecurityPolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentSecurityPolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyContentTypeOptions(v *types.ResponseHeadersPolicyContentTypeOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyContentTypeOptions"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyCorsConfig(v *types.ResponseHeadersPolicyCorsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyCorsConfig"}
	if v.AccessControlAllowOrigins == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlAllowOrigins"))
	} else if v.AccessControlAllowOrigins != nil {
		if err := validateResponseHeadersPolicyAccessControlAllowOrigins(v.AccessControlAllowOrigins); err != nil {
			invalidParams.AddNested("AccessControlAllowOrigins", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessControlAllowHeaders == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlAllowHeaders"))
	} else if v.AccessControlAllowHeaders != nil {
		if err := validateResponseHeadersPolicyAccessControlAllowHeaders(v.AccessControlAllowHeaders); err != nil {
			invalidParams.AddNested("AccessControlAllowHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessControlAllowMethods == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlAllowMethods"))
	} else if v.AccessControlAllowMethods != nil {
		if err := validateResponseHeadersPolicyAccessControlAllowMethods(v.AccessControlAllowMethods); err != nil {
			invalidParams.AddNested("AccessControlAllowMethods", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessControlAllowCredentials == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlAllowCredentials"))
	}
	if v.AccessControlExposeHeaders != nil {
		if err := validateResponseHeadersPolicyAccessControlExposeHeaders(v.AccessControlExposeHeaders); err != nil {
			invalidParams.AddNested("AccessControlExposeHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if v.OriginOverride == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginOverride"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyCustomHeader(v *types.ResponseHeadersPolicyCustomHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyCustomHeader"}
	if v.Header == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Header"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyCustomHeaderList(v []types.ResponseHeadersPolicyCustomHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyCustomHeaderList"}
	for i := range v {
		if err := validateResponseHeadersPolicyCustomHeader(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyCustomHeadersConfig(v *types.ResponseHeadersPolicyCustomHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyCustomHeadersConfig"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateResponseHeadersPolicyCustomHeaderList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyFrameOptions(v *types.ResponseHeadersPolicyFrameOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyFrameOptions"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if len(v.FrameOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FrameOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyReferrerPolicy(v *types.ResponseHeadersPolicyReferrerPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyReferrerPolicy"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if len(v.ReferrerPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ReferrerPolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyRemoveHeader(v *types.ResponseHeadersPolicyRemoveHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyRemoveHeader"}
	if v.Header == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Header"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyRemoveHeaderList(v []types.ResponseHeadersPolicyRemoveHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyRemoveHeaderList"}
	for i := range v {
		if err := validateResponseHeadersPolicyRemoveHeader(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyRemoveHeadersConfig(v *types.ResponseHeadersPolicyRemoveHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyRemoveHeadersConfig"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items != nil {
		if err := validateResponseHeadersPolicyRemoveHeaderList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicySecurityHeadersConfig(v *types.ResponseHeadersPolicySecurityHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicySecurityHeadersConfig"}
	if v.XSSProtection != nil {
		if err := validateResponseHeadersPolicyXSSProtection(v.XSSProtection); err != nil {
			invalidParams.AddNested("XSSProtection", err.(smithy.InvalidParamsError))
		}
	}
	if v.FrameOptions != nil {
		if err := validateResponseHeadersPolicyFrameOptions(v.FrameOptions); err != nil {
			invalidParams.AddNested("FrameOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferrerPolicy != nil {
		if err := validateResponseHeadersPolicyReferrerPolicy(v.ReferrerPolicy); err != nil {
			invalidParams.AddNested("ReferrerPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentSecurityPolicy != nil {
		if err := validateResponseHeadersPolicyContentSecurityPolicy(v.ContentSecurityPolicy); err != nil {
			invalidParams.AddNested("ContentSecurityPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentTypeOptions != nil {
		if err := validateResponseHeadersPolicyContentTypeOptions(v.ContentTypeOptions); err != nil {
			invalidParams.AddNested("ContentTypeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.StrictTransportSecurity != nil {
		if err := validateResponseHeadersPolicyStrictTransportSecurity(v.StrictTransportSecurity); err != nil {
			invalidParams.AddNested("StrictTransportSecurity", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyServerTimingHeadersConfig(v *types.ResponseHeadersPolicyServerTimingHeadersConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyServerTimingHeadersConfig"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyStrictTransportSecurity(v *types.ResponseHeadersPolicyStrictTransportSecurity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyStrictTransportSecurity"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if v.AccessControlMaxAgeSec == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlMaxAgeSec"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseHeadersPolicyXSSProtection(v *types.ResponseHeadersPolicyXSSProtection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseHeadersPolicyXSSProtection"}
	if v.Override == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Override"))
	}
	if v.Protection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRestrictions(v *types.Restrictions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Restrictions"}
	if v.GeoRestriction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeoRestriction"))
	} else if v.GeoRestriction != nil {
		if err := validateGeoRestriction(v.GeoRestriction); err != nil {
			invalidParams.AddNested("GeoRestriction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3Origin(v *types.S3Origin) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Origin"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.OriginAccessIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccessIdentity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3OriginConfig(v *types.S3OriginConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3OriginConfig"}
	if v.OriginAccessIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccessIdentity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSessionStickinessConfig(v *types.SessionStickinessConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SessionStickinessConfig"}
	if v.IdleTTL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdleTTL"))
	}
	if v.MaximumTTL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaximumTTL"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStagingDistributionDnsNames(v *types.StagingDistributionDnsNames) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StagingDistributionDnsNames"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStatusCodes(v *types.StatusCodes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StatusCodes"}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStreamingDistributionConfig(v *types.StreamingDistributionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamingDistributionConfig"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.S3Origin == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Origin"))
	} else if v.S3Origin != nil {
		if err := validateS3Origin(v.S3Origin); err != nil {
			invalidParams.AddNested("S3Origin", err.(smithy.InvalidParamsError))
		}
	}
	if v.Aliases != nil {
		if err := validateAliases(v.Aliases); err != nil {
			invalidParams.AddNested("Aliases", err.(smithy.InvalidParamsError))
		}
	}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if v.Logging != nil {
		if err := validateStreamingLoggingConfig(v.Logging); err != nil {
			invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrustedSigners == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrustedSigners"))
	} else if v.TrustedSigners != nil {
		if err := validateTrustedSigners(v.TrustedSigners); err != nil {
			invalidParams.AddNested("TrustedSigners", err.(smithy.InvalidParamsError))
		}
	}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStreamingDistributionConfigWithTags(v *types.StreamingDistributionConfigWithTags) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamingDistributionConfigWithTags"}
	if v.StreamingDistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingDistributionConfig"))
	} else if v.StreamingDistributionConfig != nil {
		if err := validateStreamingDistributionConfig(v.StreamingDistributionConfig); err != nil {
			invalidParams.AddNested("StreamingDistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStreamingLoggingConfig(v *types.StreamingLoggingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamingLoggingConfig"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.Prefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStringSchemaConfig(v *types.StringSchemaConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StringSchemaConfig"}
	if v.Required == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Required"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTag(v *types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTags(v *types.Tags) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
	if v.Items != nil {
		if err := validateTagList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTenantConfig(v *types.TenantConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TenantConfig"}
	if v.ParameterDefinitions != nil {
		if err := validateParameterDefinitions(v.ParameterDefinitions); err != nil {
			invalidParams.AddNested("ParameterDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTrafficConfig(v *types.TrafficConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrafficConfig"}
	if v.SingleWeightConfig != nil {
		if err := validateContinuousDeploymentSingleWeightConfig(v.SingleWeightConfig); err != nil {
			invalidParams.AddNested("SingleWeightConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SingleHeaderConfig != nil {
		if err := validateContinuousDeploymentSingleHeaderConfig(v.SingleHeaderConfig); err != nil {
			invalidParams.AddNested("SingleHeaderConfig", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTrustedKeyGroups(v *types.TrustedKeyGroups) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrustedKeyGroups"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTrustedSigners(v *types.TrustedSigners) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrustedSigners"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.Quantity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Quantity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVpcOriginConfig(v *types.VpcOriginConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VpcOriginConfig"}
	if v.VpcOriginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcOriginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVpcOriginEndpointConfig(v *types.VpcOriginEndpointConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VpcOriginEndpointConfig"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.HTTPPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HTTPPort"))
	}
	if v.HTTPSPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HTTPSPort"))
	}
	if len(v.OriginProtocolPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OriginProtocolPolicy"))
	}
	if v.OriginSslProtocols != nil {
		if err := validateOriginSslProtocols(v.OriginSslProtocols); err != nil {
			invalidParams.AddNested("OriginSslProtocols", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWebAclCustomization(v *types.WebAclCustomization) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WebAclCustomization"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateAliasInput(v *AssociateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAliasInput"}
	if v.TargetDistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDistributionId"))
	}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDistributionTenantWebACLInput(v *AssociateDistributionTenantWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDistributionTenantWebACLInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.WebACLArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDistributionWebACLInput(v *AssociateDistributionWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDistributionWebACLInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.WebACLArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyDistributionInput(v *CopyDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyDistributionInput"}
	if v.PrimaryDistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryDistributionId"))
	}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAnycastIpListInput(v *CreateAnycastIpListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnycastIpListInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IpCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpCount"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCachePolicyInput(v *CreateCachePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCachePolicyInput"}
	if v.CachePolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CachePolicyConfig"))
	} else if v.CachePolicyConfig != nil {
		if err := validateCachePolicyConfig(v.CachePolicyConfig); err != nil {
			invalidParams.AddNested("CachePolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCloudFrontOriginAccessIdentityInput(v *CreateCloudFrontOriginAccessIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCloudFrontOriginAccessIdentityInput"}
	if v.CloudFrontOriginAccessIdentityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudFrontOriginAccessIdentityConfig"))
	} else if v.CloudFrontOriginAccessIdentityConfig != nil {
		if err := validateCloudFrontOriginAccessIdentityConfig(v.CloudFrontOriginAccessIdentityConfig); err != nil {
			invalidParams.AddNested("CloudFrontOriginAccessIdentityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConnectionGroupInput(v *CreateConnectionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContinuousDeploymentPolicyInput(v *CreateContinuousDeploymentPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContinuousDeploymentPolicyInput"}
	if v.ContinuousDeploymentPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContinuousDeploymentPolicyConfig"))
	} else if v.ContinuousDeploymentPolicyConfig != nil {
		if err := validateContinuousDeploymentPolicyConfig(v.ContinuousDeploymentPolicyConfig); err != nil {
			invalidParams.AddNested("ContinuousDeploymentPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDistributionInput(v *CreateDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDistributionInput"}
	if v.DistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionConfig"))
	} else if v.DistributionConfig != nil {
		if err := validateDistributionConfig(v.DistributionConfig); err != nil {
			invalidParams.AddNested("DistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDistributionTenantInput(v *CreateDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDistributionTenantInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Domains == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domains"))
	} else if v.Domains != nil {
		if err := validateDomainList(v.Domains); err != nil {
			invalidParams.AddNested("Domains", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Customizations != nil {
		if err := validateCustomizations(v.Customizations); err != nil {
			invalidParams.AddNested("Customizations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManagedCertificateRequest != nil {
		if err := validateManagedCertificateRequest(v.ManagedCertificateRequest); err != nil {
			invalidParams.AddNested("ManagedCertificateRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDistributionWithTagsInput(v *CreateDistributionWithTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDistributionWithTagsInput"}
	if v.DistributionConfigWithTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionConfigWithTags"))
	} else if v.DistributionConfigWithTags != nil {
		if err := validateDistributionConfigWithTags(v.DistributionConfigWithTags); err != nil {
			invalidParams.AddNested("DistributionConfigWithTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFieldLevelEncryptionConfigInput(v *CreateFieldLevelEncryptionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFieldLevelEncryptionConfigInput"}
	if v.FieldLevelEncryptionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldLevelEncryptionConfig"))
	} else if v.FieldLevelEncryptionConfig != nil {
		if err := validateFieldLevelEncryptionConfig(v.FieldLevelEncryptionConfig); err != nil {
			invalidParams.AddNested("FieldLevelEncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFieldLevelEncryptionProfileInput(v *CreateFieldLevelEncryptionProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFieldLevelEncryptionProfileInput"}
	if v.FieldLevelEncryptionProfileConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldLevelEncryptionProfileConfig"))
	} else if v.FieldLevelEncryptionProfileConfig != nil {
		if err := validateFieldLevelEncryptionProfileConfig(v.FieldLevelEncryptionProfileConfig); err != nil {
			invalidParams.AddNested("FieldLevelEncryptionProfileConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFunctionInput(v *CreateFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.FunctionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionConfig"))
	} else if v.FunctionConfig != nil {
		if err := validateFunctionConfig(v.FunctionConfig); err != nil {
			invalidParams.AddNested("FunctionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunctionCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInvalidationForDistributionTenantInput(v *CreateInvalidationForDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInvalidationForDistributionTenantInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.InvalidationBatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InvalidationBatch"))
	} else if v.InvalidationBatch != nil {
		if err := validateInvalidationBatch(v.InvalidationBatch); err != nil {
			invalidParams.AddNested("InvalidationBatch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInvalidationInput(v *CreateInvalidationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInvalidationInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if v.InvalidationBatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InvalidationBatch"))
	} else if v.InvalidationBatch != nil {
		if err := validateInvalidationBatch(v.InvalidationBatch); err != nil {
			invalidParams.AddNested("InvalidationBatch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateKeyGroupInput(v *CreateKeyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKeyGroupInput"}
	if v.KeyGroupConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyGroupConfig"))
	} else if v.KeyGroupConfig != nil {
		if err := validateKeyGroupConfig(v.KeyGroupConfig); err != nil {
			invalidParams.AddNested("KeyGroupConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateKeyValueStoreInput(v *CreateKeyValueStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKeyValueStoreInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ImportSource != nil {
		if err := validateImportSource(v.ImportSource); err != nil {
			invalidParams.AddNested("ImportSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMonitoringSubscriptionInput(v *CreateMonitoringSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMonitoringSubscriptionInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if v.MonitoringSubscription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringSubscription"))
	} else if v.MonitoringSubscription != nil {
		if err := validateMonitoringSubscription(v.MonitoringSubscription); err != nil {
			invalidParams.AddNested("MonitoringSubscription", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateOriginAccessControlInput(v *CreateOriginAccessControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateOriginAccessControlInput"}
	if v.OriginAccessControlConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccessControlConfig"))
	} else if v.OriginAccessControlConfig != nil {
		if err := validateOriginAccessControlConfig(v.OriginAccessControlConfig); err != nil {
			invalidParams.AddNested("OriginAccessControlConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateOriginRequestPolicyInput(v *CreateOriginRequestPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateOriginRequestPolicyInput"}
	if v.OriginRequestPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginRequestPolicyConfig"))
	} else if v.OriginRequestPolicyConfig != nil {
		if err := validateOriginRequestPolicyConfig(v.OriginRequestPolicyConfig); err != nil {
			invalidParams.AddNested("OriginRequestPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePublicKeyInput(v *CreatePublicKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePublicKeyInput"}
	if v.PublicKeyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyConfig"))
	} else if v.PublicKeyConfig != nil {
		if err := validatePublicKeyConfig(v.PublicKeyConfig); err != nil {
			invalidParams.AddNested("PublicKeyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRealtimeLogConfigInput(v *CreateRealtimeLogConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRealtimeLogConfigInput"}
	if v.EndPoints == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndPoints"))
	} else if v.EndPoints != nil {
		if err := validateEndPointList(v.EndPoints); err != nil {
			invalidParams.AddNested("EndPoints", err.(smithy.InvalidParamsError))
		}
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SamplingRate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SamplingRate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateResponseHeadersPolicyInput(v *CreateResponseHeadersPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResponseHeadersPolicyInput"}
	if v.ResponseHeadersPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseHeadersPolicyConfig"))
	} else if v.ResponseHeadersPolicyConfig != nil {
		if err := validateResponseHeadersPolicyConfig(v.ResponseHeadersPolicyConfig); err != nil {
			invalidParams.AddNested("ResponseHeadersPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStreamingDistributionInput(v *CreateStreamingDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingDistributionInput"}
	if v.StreamingDistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingDistributionConfig"))
	} else if v.StreamingDistributionConfig != nil {
		if err := validateStreamingDistributionConfig(v.StreamingDistributionConfig); err != nil {
			invalidParams.AddNested("StreamingDistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStreamingDistributionWithTagsInput(v *CreateStreamingDistributionWithTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingDistributionWithTagsInput"}
	if v.StreamingDistributionConfigWithTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingDistributionConfigWithTags"))
	} else if v.StreamingDistributionConfigWithTags != nil {
		if err := validateStreamingDistributionConfigWithTags(v.StreamingDistributionConfigWithTags); err != nil {
			invalidParams.AddNested("StreamingDistributionConfigWithTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcOriginInput(v *CreateVpcOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcOriginInput"}
	if v.VpcOriginEndpointConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcOriginEndpointConfig"))
	} else if v.VpcOriginEndpointConfig != nil {
		if err := validateVpcOriginEndpointConfig(v.VpcOriginEndpointConfig); err != nil {
			invalidParams.AddNested("VpcOriginEndpointConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAnycastIpListInput(v *DeleteAnycastIpListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAnycastIpListInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCachePolicyInput(v *DeleteCachePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCachePolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCloudFrontOriginAccessIdentityInput(v *DeleteCloudFrontOriginAccessIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCloudFrontOriginAccessIdentityInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConnectionGroupInput(v *DeleteConnectionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContinuousDeploymentPolicyInput(v *DeleteContinuousDeploymentPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContinuousDeploymentPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDistributionInput(v *DeleteDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDistributionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDistributionTenantInput(v *DeleteDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDistributionTenantInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFieldLevelEncryptionConfigInput(v *DeleteFieldLevelEncryptionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFieldLevelEncryptionConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFieldLevelEncryptionProfileInput(v *DeleteFieldLevelEncryptionProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFieldLevelEncryptionProfileInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFunctionInput(v *DeleteFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteKeyGroupInput(v *DeleteKeyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeyGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteKeyValueStoreInput(v *DeleteKeyValueStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeyValueStoreInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMonitoringSubscriptionInput(v *DeleteMonitoringSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMonitoringSubscriptionInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteOriginAccessControlInput(v *DeleteOriginAccessControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOriginAccessControlInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteOriginRequestPolicyInput(v *DeleteOriginRequestPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOriginRequestPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePublicKeyInput(v *DeletePublicKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePublicKeyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteResponseHeadersPolicyInput(v *DeleteResponseHeadersPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteResponseHeadersPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStreamingDistributionInput(v *DeleteStreamingDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamingDistributionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcOriginInput(v *DeleteVpcOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcOriginInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFunctionInput(v *DescribeFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeKeyValueStoreInput(v *DescribeKeyValueStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeKeyValueStoreInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateDistributionTenantWebACLInput(v *DisassociateDistributionTenantWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateDistributionTenantWebACLInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateDistributionWebACLInput(v *DisassociateDistributionWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateDistributionWebACLInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAnycastIpListInput(v *GetAnycastIpListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAnycastIpListInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCachePolicyConfigInput(v *GetCachePolicyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCachePolicyConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCachePolicyInput(v *GetCachePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCachePolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCloudFrontOriginAccessIdentityConfigInput(v *GetCloudFrontOriginAccessIdentityConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCloudFrontOriginAccessIdentityConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCloudFrontOriginAccessIdentityInput(v *GetCloudFrontOriginAccessIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCloudFrontOriginAccessIdentityInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConnectionGroupByRoutingEndpointInput(v *GetConnectionGroupByRoutingEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConnectionGroupByRoutingEndpointInput"}
	if v.RoutingEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingEndpoint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConnectionGroupInput(v *GetConnectionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConnectionGroupInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetContinuousDeploymentPolicyConfigInput(v *GetContinuousDeploymentPolicyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContinuousDeploymentPolicyConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetContinuousDeploymentPolicyInput(v *GetContinuousDeploymentPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContinuousDeploymentPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDistributionConfigInput(v *GetDistributionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDistributionInput(v *GetDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDistributionTenantByDomainInput(v *GetDistributionTenantByDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionTenantByDomainInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDistributionTenantInput(v *GetDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionTenantInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFieldLevelEncryptionConfigInput(v *GetFieldLevelEncryptionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFieldLevelEncryptionConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFieldLevelEncryptionInput(v *GetFieldLevelEncryptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFieldLevelEncryptionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFieldLevelEncryptionProfileConfigInput(v *GetFieldLevelEncryptionProfileConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFieldLevelEncryptionProfileConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFieldLevelEncryptionProfileInput(v *GetFieldLevelEncryptionProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFieldLevelEncryptionProfileInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFunctionInput(v *GetFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInvalidationForDistributionTenantInput(v *GetInvalidationForDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInvalidationForDistributionTenantInput"}
	if v.DistributionTenantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionTenantId"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInvalidationInput(v *GetInvalidationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInvalidationInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetKeyGroupConfigInput(v *GetKeyGroupConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetKeyGroupConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetKeyGroupInput(v *GetKeyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetKeyGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetManagedCertificateDetailsInput(v *GetManagedCertificateDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetManagedCertificateDetailsInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMonitoringSubscriptionInput(v *GetMonitoringSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMonitoringSubscriptionInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOriginAccessControlConfigInput(v *GetOriginAccessControlConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOriginAccessControlConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOriginAccessControlInput(v *GetOriginAccessControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOriginAccessControlInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOriginRequestPolicyConfigInput(v *GetOriginRequestPolicyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOriginRequestPolicyConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOriginRequestPolicyInput(v *GetOriginRequestPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOriginRequestPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPublicKeyConfigInput(v *GetPublicKeyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPublicKeyConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPublicKeyInput(v *GetPublicKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPublicKeyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResponseHeadersPolicyConfigInput(v *GetResponseHeadersPolicyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResponseHeadersPolicyConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResponseHeadersPolicyInput(v *GetResponseHeadersPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResponseHeadersPolicyInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingDistributionConfigInput(v *GetStreamingDistributionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingDistributionConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingDistributionInput(v *GetStreamingDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingDistributionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVpcOriginInput(v *GetVpcOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVpcOriginInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListConflictingAliasesInput(v *ListConflictingAliasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListConflictingAliasesInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByAnycastIpListIdInput(v *ListDistributionsByAnycastIpListIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByAnycastIpListIdInput"}
	if v.AnycastIpListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnycastIpListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByCachePolicyIdInput(v *ListDistributionsByCachePolicyIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByCachePolicyIdInput"}
	if v.CachePolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CachePolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByConnectionModeInput(v *ListDistributionsByConnectionModeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByConnectionModeInput"}
	if len(v.ConnectionMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByKeyGroupInput(v *ListDistributionsByKeyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByKeyGroupInput"}
	if v.KeyGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByOriginRequestPolicyIdInput(v *ListDistributionsByOriginRequestPolicyIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByOriginRequestPolicyIdInput"}
	if v.OriginRequestPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginRequestPolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByResponseHeadersPolicyIdInput(v *ListDistributionsByResponseHeadersPolicyIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByResponseHeadersPolicyIdInput"}
	if v.ResponseHeadersPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseHeadersPolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByVpcOriginIdInput(v *ListDistributionsByVpcOriginIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByVpcOriginIdInput"}
	if v.VpcOriginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcOriginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDistributionsByWebACLIdInput(v *ListDistributionsByWebACLIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDistributionsByWebACLIdInput"}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDomainConflictsInput(v *ListDomainConflictsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDomainConflictsInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.DomainControlValidationResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainControlValidationResource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListInvalidationsForDistributionTenantInput(v *ListInvalidationsForDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListInvalidationsForDistributionTenantInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListInvalidationsInput(v *ListInvalidationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListInvalidationsInput"}
	if v.DistributionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPublishFunctionInput(v *PublishFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PublishFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestFunctionInput(v *TestFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if v.EventObject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventObject"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCachePolicyInput(v *UpdateCachePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCachePolicyInput"}
	if v.CachePolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CachePolicyConfig"))
	} else if v.CachePolicyConfig != nil {
		if err := validateCachePolicyConfig(v.CachePolicyConfig); err != nil {
			invalidParams.AddNested("CachePolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCloudFrontOriginAccessIdentityInput(v *UpdateCloudFrontOriginAccessIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCloudFrontOriginAccessIdentityInput"}
	if v.CloudFrontOriginAccessIdentityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudFrontOriginAccessIdentityConfig"))
	} else if v.CloudFrontOriginAccessIdentityConfig != nil {
		if err := validateCloudFrontOriginAccessIdentityConfig(v.CloudFrontOriginAccessIdentityConfig); err != nil {
			invalidParams.AddNested("CloudFrontOriginAccessIdentityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConnectionGroupInput(v *UpdateConnectionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContinuousDeploymentPolicyInput(v *UpdateContinuousDeploymentPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContinuousDeploymentPolicyInput"}
	if v.ContinuousDeploymentPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContinuousDeploymentPolicyConfig"))
	} else if v.ContinuousDeploymentPolicyConfig != nil {
		if err := validateContinuousDeploymentPolicyConfig(v.ContinuousDeploymentPolicyConfig); err != nil {
			invalidParams.AddNested("ContinuousDeploymentPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDistributionInput(v *UpdateDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDistributionInput"}
	if v.DistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionConfig"))
	} else if v.DistributionConfig != nil {
		if err := validateDistributionConfig(v.DistributionConfig); err != nil {
			invalidParams.AddNested("DistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDistributionTenantInput(v *UpdateDistributionTenantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDistributionTenantInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Domains != nil {
		if err := validateDomainList(v.Domains); err != nil {
			invalidParams.AddNested("Domains", err.(smithy.InvalidParamsError))
		}
	}
	if v.Customizations != nil {
		if err := validateCustomizations(v.Customizations); err != nil {
			invalidParams.AddNested("Customizations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if v.ManagedCertificateRequest != nil {
		if err := validateManagedCertificateRequest(v.ManagedCertificateRequest); err != nil {
			invalidParams.AddNested("ManagedCertificateRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDistributionWithStagingConfigInput(v *UpdateDistributionWithStagingConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDistributionWithStagingConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDomainAssociationInput(v *UpdateDomainAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainAssociationInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.TargetResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetResource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFieldLevelEncryptionConfigInput(v *UpdateFieldLevelEncryptionConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFieldLevelEncryptionConfigInput"}
	if v.FieldLevelEncryptionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldLevelEncryptionConfig"))
	} else if v.FieldLevelEncryptionConfig != nil {
		if err := validateFieldLevelEncryptionConfig(v.FieldLevelEncryptionConfig); err != nil {
			invalidParams.AddNested("FieldLevelEncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFieldLevelEncryptionProfileInput(v *UpdateFieldLevelEncryptionProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFieldLevelEncryptionProfileInput"}
	if v.FieldLevelEncryptionProfileConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldLevelEncryptionProfileConfig"))
	} else if v.FieldLevelEncryptionProfileConfig != nil {
		if err := validateFieldLevelEncryptionProfileConfig(v.FieldLevelEncryptionProfileConfig); err != nil {
			invalidParams.AddNested("FieldLevelEncryptionProfileConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFunctionInput(v *UpdateFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFunctionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if v.FunctionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionConfig"))
	} else if v.FunctionConfig != nil {
		if err := validateFunctionConfig(v.FunctionConfig); err != nil {
			invalidParams.AddNested("FunctionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunctionCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateKeyGroupInput(v *UpdateKeyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateKeyGroupInput"}
	if v.KeyGroupConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyGroupConfig"))
	} else if v.KeyGroupConfig != nil {
		if err := validateKeyGroupConfig(v.KeyGroupConfig); err != nil {
			invalidParams.AddNested("KeyGroupConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateKeyValueStoreInput(v *UpdateKeyValueStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateKeyValueStoreInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateOriginAccessControlInput(v *UpdateOriginAccessControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateOriginAccessControlInput"}
	if v.OriginAccessControlConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccessControlConfig"))
	} else if v.OriginAccessControlConfig != nil {
		if err := validateOriginAccessControlConfig(v.OriginAccessControlConfig); err != nil {
			invalidParams.AddNested("OriginAccessControlConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateOriginRequestPolicyInput(v *UpdateOriginRequestPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateOriginRequestPolicyInput"}
	if v.OriginRequestPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginRequestPolicyConfig"))
	} else if v.OriginRequestPolicyConfig != nil {
		if err := validateOriginRequestPolicyConfig(v.OriginRequestPolicyConfig); err != nil {
			invalidParams.AddNested("OriginRequestPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePublicKeyInput(v *UpdatePublicKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePublicKeyInput"}
	if v.PublicKeyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyConfig"))
	} else if v.PublicKeyConfig != nil {
		if err := validatePublicKeyConfig(v.PublicKeyConfig); err != nil {
			invalidParams.AddNested("PublicKeyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRealtimeLogConfigInput(v *UpdateRealtimeLogConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRealtimeLogConfigInput"}
	if v.EndPoints != nil {
		if err := validateEndPointList(v.EndPoints); err != nil {
			invalidParams.AddNested("EndPoints", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResponseHeadersPolicyInput(v *UpdateResponseHeadersPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResponseHeadersPolicyInput"}
	if v.ResponseHeadersPolicyConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseHeadersPolicyConfig"))
	} else if v.ResponseHeadersPolicyConfig != nil {
		if err := validateResponseHeadersPolicyConfig(v.ResponseHeadersPolicyConfig); err != nil {
			invalidParams.AddNested("ResponseHeadersPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStreamingDistributionInput(v *UpdateStreamingDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStreamingDistributionInput"}
	if v.StreamingDistributionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingDistributionConfig"))
	} else if v.StreamingDistributionConfig != nil {
		if err := validateStreamingDistributionConfig(v.StreamingDistributionConfig); err != nil {
			invalidParams.AddNested("StreamingDistributionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateVpcOriginInput(v *UpdateVpcOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVpcOriginInput"}
	if v.VpcOriginEndpointConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcOriginEndpointConfig"))
	} else if v.VpcOriginEndpointConfig != nil {
		if err := validateVpcOriginEndpointConfig(v.VpcOriginEndpointConfig); err != nil {
			invalidParams.AddNested("VpcOriginEndpointConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IfMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IfMatch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyDnsConfigurationInput(v *VerifyDnsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyDnsConfigurationInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}