service/lightsail/validators.go

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

package lightsail

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

type validateOpAllocateStaticIp struct {
}

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

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

type validateOpAttachCertificateToDistribution struct {
}

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

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

type validateOpAttachDisk struct {
}

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

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

type validateOpAttachInstancesToLoadBalancer struct {
}

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

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

type validateOpAttachLoadBalancerTlsCertificate struct {
}

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

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

type validateOpAttachStaticIp struct {
}

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

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

type validateOpCloseInstancePublicPorts struct {
}

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

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

type validateOpCopySnapshot struct {
}

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

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

type validateOpCreateBucketAccessKey struct {
}

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

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

type validateOpCreateBucket struct {
}

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

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

type validateOpCreateCertificate struct {
}

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

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

type validateOpCreateCloudFormationStack struct {
}

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

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

type validateOpCreateContactMethod struct {
}

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

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

type validateOpCreateContainerServiceDeployment struct {
}

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

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

type validateOpCreateContainerService struct {
}

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

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

type validateOpCreateDiskFromSnapshot struct {
}

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

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

type validateOpCreateDisk struct {
}

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

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

type validateOpCreateDiskSnapshot struct {
}

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

func (m *validateOpCreateDiskSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDiskSnapshotInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDiskSnapshotInput(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 validateOpCreateDomainEntry struct {
}

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

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

type validateOpCreateDomain struct {
}

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

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

type validateOpCreateGUISessionAccessDetails struct {
}

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

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

type validateOpCreateInstancesFromSnapshot struct {
}

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

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

type validateOpCreateInstances struct {
}

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

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

type validateOpCreateInstanceSnapshot struct {
}

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

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

type validateOpCreateKeyPair struct {
}

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

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

type validateOpCreateLoadBalancer struct {
}

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

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

type validateOpCreateLoadBalancerTlsCertificate struct {
}

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

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

type validateOpCreateRelationalDatabaseFromSnapshot struct {
}

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

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

type validateOpCreateRelationalDatabase struct {
}

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

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

type validateOpCreateRelationalDatabaseSnapshot struct {
}

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

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

type validateOpDeleteAlarm struct {
}

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

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

type validateOpDeleteAutoSnapshot struct {
}

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

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

type validateOpDeleteBucketAccessKey struct {
}

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

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

type validateOpDeleteBucket struct {
}

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

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

type validateOpDeleteCertificate struct {
}

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

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

type validateOpDeleteContactMethod struct {
}

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

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

type validateOpDeleteContainerImage struct {
}

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

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

type validateOpDeleteContainerService struct {
}

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

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

type validateOpDeleteDisk struct {
}

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

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

type validateOpDeleteDiskSnapshot struct {
}

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

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

type validateOpDeleteDomainEntry struct {
}

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

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

type validateOpDeleteDomain struct {
}

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

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

type validateOpDeleteInstance struct {
}

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

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

type validateOpDeleteInstanceSnapshot struct {
}

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

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

type validateOpDeleteKeyPair struct {
}

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

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

type validateOpDeleteKnownHostKeys struct {
}

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

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

type validateOpDeleteLoadBalancer struct {
}

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

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

type validateOpDeleteLoadBalancerTlsCertificate struct {
}

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

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

type validateOpDeleteRelationalDatabase struct {
}

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

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

type validateOpDeleteRelationalDatabaseSnapshot struct {
}

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

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

type validateOpDetachCertificateFromDistribution struct {
}

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

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

type validateOpDetachDisk struct {
}

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

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

type validateOpDetachInstancesFromLoadBalancer struct {
}

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

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

type validateOpDetachStaticIp struct {
}

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

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

type validateOpDisableAddOn struct {
}

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

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

type validateOpEnableAddOn struct {
}

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

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

type validateOpExportSnapshot struct {
}

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

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

type validateOpGetAutoSnapshots struct {
}

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

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

type validateOpGetBucketAccessKeys struct {
}

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

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

type validateOpGetBucketMetricData struct {
}

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

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

type validateOpGetContainerImages struct {
}

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

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

type validateOpGetContainerLog struct {
}

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

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

type validateOpGetContainerServiceDeployments struct {
}

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

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

type validateOpGetContainerServiceMetricData struct {
}

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

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

type validateOpGetCostEstimate struct {
}

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

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

type validateOpGetDisk struct {
}

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

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

type validateOpGetDiskSnapshot struct {
}

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

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

type validateOpGetDistributionMetricData struct {
}

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

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

type validateOpGetDomain struct {
}

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

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

type validateOpGetInstanceAccessDetails struct {
}

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

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

type validateOpGetInstance struct {
}

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

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

type validateOpGetInstanceMetricData struct {
}

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

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

type validateOpGetInstancePortStates struct {
}

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

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

type validateOpGetInstanceSnapshot struct {
}

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

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

type validateOpGetInstanceState struct {
}

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

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

type validateOpGetKeyPair struct {
}

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

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

type validateOpGetLoadBalancer struct {
}

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

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

type validateOpGetLoadBalancerMetricData struct {
}

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

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

type validateOpGetLoadBalancerTlsCertificates struct {
}

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

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

type validateOpGetOperation struct {
}

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

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

type validateOpGetOperationsForResource struct {
}

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

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

type validateOpGetRelationalDatabaseEvents struct {
}

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

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

type validateOpGetRelationalDatabase struct {
}

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

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

type validateOpGetRelationalDatabaseLogEvents struct {
}

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

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

type validateOpGetRelationalDatabaseLogStreams struct {
}

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

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

type validateOpGetRelationalDatabaseMasterUserPassword struct {
}

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

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

type validateOpGetRelationalDatabaseMetricData struct {
}

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

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

type validateOpGetRelationalDatabaseParameters struct {
}

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

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

type validateOpGetRelationalDatabaseSnapshot struct {
}

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

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

type validateOpGetSetupHistory struct {
}

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

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

type validateOpGetStaticIp struct {
}

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

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

type validateOpImportKeyPair struct {
}

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

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

type validateOpOpenInstancePublicPorts struct {
}

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

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

type validateOpPutAlarm struct {
}

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

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

type validateOpPutInstancePublicPorts struct {
}

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

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

type validateOpRebootInstance struct {
}

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

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

type validateOpRebootRelationalDatabase struct {
}

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

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

type validateOpRegisterContainerImage struct {
}

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

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

type validateOpReleaseStaticIp struct {
}

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

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

type validateOpSendContactMethodVerification struct {
}

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

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

type validateOpSetIpAddressType struct {
}

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

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

type validateOpSetResourceAccessForBucket struct {
}

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

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

type validateOpSetupInstanceHttps struct {
}

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

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

type validateOpStartGUISession struct {
}

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

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

type validateOpStartInstance struct {
}

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

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

type validateOpStartRelationalDatabase struct {
}

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

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

type validateOpStopGUISession struct {
}

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

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

type validateOpStopInstance struct {
}

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

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

type validateOpStopRelationalDatabase struct {
}

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

func (m *validateOpStopRelationalDatabase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StopRelationalDatabaseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStopRelationalDatabaseInput(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 validateOpTestAlarm struct {
}

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

func (m *validateOpTestAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TestAlarmInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTestAlarmInput(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 validateOpUpdateBucketBundle struct {
}

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

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

type validateOpUpdateBucket struct {
}

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

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

type validateOpUpdateContainerService struct {
}

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

func (m *validateOpUpdateContainerService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateContainerServiceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateContainerServiceInput(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 validateOpUpdateDomainEntry struct {
}

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

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

type validateOpUpdateInstanceMetadataOptions struct {
}

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

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

type validateOpUpdateLoadBalancerAttribute struct {
}

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

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

type validateOpUpdateRelationalDatabase struct {
}

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

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

type validateOpUpdateRelationalDatabaseParameters struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateContainerServiceDeploymentRequest(v *types.ContainerServiceDeploymentRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerServiceDeploymentRequest"}
	if v.PublicEndpoint != nil {
		if err := validateEndpointRequest(v.PublicEndpoint); err != nil {
			invalidParams.AddNested("PublicEndpoint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEndpointRequest(v *types.EndpointRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EndpointRequest"}
	if v.ContainerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
	}
	if v.ContainerPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerPort"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceEntry(v *types.InstanceEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceEntry"}
	if v.SourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceName"))
	}
	if v.InstanceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if len(v.PortInfoSource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PortInfoSource"))
	}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAttachCertificateToDistributionInput(v *AttachCertificateToDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachCertificateToDistributionInput"}
	if v.DistributionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
	}
	if v.CertificateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachDiskInput(v *AttachDiskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachDiskInput"}
	if v.DiskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if v.DiskPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachInstancesToLoadBalancerInput(v *AttachInstancesToLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachInstancesToLoadBalancerInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.InstanceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachLoadBalancerTlsCertificateInput(v *AttachLoadBalancerTlsCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachLoadBalancerTlsCertificateInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.CertificateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachStaticIpInput(v *AttachStaticIpInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachStaticIpInput"}
	if v.StaticIpName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StaticIpName"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCloseInstancePublicPortsInput(v *CloseInstancePublicPortsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloseInstancePublicPortsInput"}
	if v.PortInfo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortInfo"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
	if v.TargetSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotName"))
	}
	if len(v.SourceRegion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateBucketInput(v *CreateBucketInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBucketInput"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCertificateInput(v *CreateCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateInput"}
	if v.CertificateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCloudFormationStackInput(v *CreateCloudFormationStackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCloudFormationStackInput"}
	if v.Instances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Instances"))
	} else if v.Instances != nil {
		if err := validateInstanceEntryList(v.Instances); err != nil {
			invalidParams.AddNested("Instances", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContactMethodInput(v *CreateContactMethodInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContactMethodInput"}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.ContactEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactEndpoint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContainerServiceDeploymentInput(v *CreateContainerServiceDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerServiceDeploymentInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if v.PublicEndpoint != nil {
		if err := validateEndpointRequest(v.PublicEndpoint); err != nil {
			invalidParams.AddNested("PublicEndpoint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContainerServiceInput(v *CreateContainerServiceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerServiceInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if len(v.Power) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Power"))
	}
	if v.Scale == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scale"))
	}
	if v.Deployment != nil {
		if err := validateContainerServiceDeploymentRequest(v.Deployment); err != nil {
			invalidParams.AddNested("Deployment", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDiskFromSnapshotInput(v *CreateDiskFromSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskFromSnapshotInput"}
	if v.DiskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
	}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if v.SizeInGb == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeInGb"))
	}
	if v.AddOns != nil {
		if err := validateAddOnRequestList(v.AddOns); err != nil {
			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDiskInput(v *CreateDiskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskInput"}
	if v.DiskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskName"))
	}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if v.SizeInGb == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeInGb"))
	}
	if v.AddOns != nil {
		if err := validateAddOnRequestList(v.AddOns); err != nil {
			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDiskSnapshotInput(v *CreateDiskSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDiskSnapshotInput"}
	if v.DiskSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskSnapshotName"))
	}
	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.DistributionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
	}
	if v.Origin == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
	}
	if v.DefaultCacheBehavior == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultCacheBehavior"))
	}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDomainEntryInput(v *CreateDomainEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainEntryInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.DomainEntry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateInstancesFromSnapshotInput(v *CreateInstancesFromSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstancesFromSnapshotInput"}
	if v.InstanceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
	}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if v.AddOns != nil {
		if err := validateAddOnRequestList(v.AddOns); err != nil {
			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstancesInput(v *CreateInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstancesInput"}
	if v.InstanceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
	}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if v.BlueprintId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintId"))
	}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if v.AddOns != nil {
		if err := validateAddOnRequestList(v.AddOns); err != nil {
			invalidParams.AddNested("AddOns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstanceSnapshotInput(v *CreateInstanceSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceSnapshotInput"}
	if v.InstanceSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceSnapshotName"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateLoadBalancerTlsCertificateInput(v *CreateLoadBalancerTlsCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLoadBalancerTlsCertificateInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.CertificateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
	}
	if v.CertificateDomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateDomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateRelationalDatabaseInput(v *CreateRelationalDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRelationalDatabaseInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	if v.RelationalDatabaseBlueprintId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseBlueprintId"))
	}
	if v.RelationalDatabaseBundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseBundleId"))
	}
	if v.MasterDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterDatabaseName"))
	}
	if v.MasterUsername == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRelationalDatabaseSnapshotInput(v *CreateRelationalDatabaseSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRelationalDatabaseSnapshotInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	if v.RelationalDatabaseSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseSnapshotName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAutoSnapshotInput(v *DeleteAutoSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAutoSnapshotInput"}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.Date == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Date"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteBucketAccessKeyInput(v *DeleteBucketAccessKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBucketAccessKeyInput"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.AccessKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessKeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteContainerImageInput(v *DeleteContainerImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContainerImageInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if v.Image == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Image"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteDomainEntryInput(v *DeleteDomainEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainEntryInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.DomainEntry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpDeleteLoadBalancerTlsCertificateInput(v *DeleteLoadBalancerTlsCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLoadBalancerTlsCertificateInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.CertificateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDetachInstancesFromLoadBalancerInput(v *DetachInstancesFromLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachInstancesFromLoadBalancerInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.InstanceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDisableAddOnInput(v *DisableAddOnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableAddOnInput"}
	if len(v.AddOnType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AddOnType"))
	}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableAddOnInput(v *EnableAddOnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableAddOnInput"}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.AddOnRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AddOnRequest"))
	} else if v.AddOnRequest != nil {
		if err := validateAddOnRequest(v.AddOnRequest); err != nil {
			invalidParams.AddNested("AddOnRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetBucketMetricDataInput(v *GetBucketMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBucketMetricDataInput"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetContainerLogInput(v *GetContainerLogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContainerLogInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if v.ContainerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetContainerServiceMetricDataInput(v *GetContainerServiceMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContainerServiceMetricDataInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCostEstimateInput(v *GetCostEstimateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCostEstimateInput"}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetDistributionMetricDataInput(v *GetDistributionMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDistributionMetricDataInput"}
	if v.DistributionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetInstanceMetricDataInput(v *GetInstanceMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceMetricDataInput"}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpGetLoadBalancerMetricDataInput(v *GetLoadBalancerMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLoadBalancerMetricDataInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpGetRelationalDatabaseLogEventsInput(v *GetRelationalDatabaseLogEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseLogEventsInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	if v.LogStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogStreamName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetRelationalDatabaseMetricDataInput(v *GetRelationalDatabaseMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRelationalDatabaseMetricDataInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpImportKeyPairInput(v *ImportKeyPairInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportKeyPairInput"}
	if v.KeyPairName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyPairName"))
	}
	if v.PublicKeyBase64 == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyBase64"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpOpenInstancePublicPortsInput(v *OpenInstancePublicPortsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenInstancePublicPortsInput"}
	if v.PortInfo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortInfo"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutAlarmInput(v *PutAlarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAlarmInput"}
	if v.AlarmName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlarmName"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.MonitoredResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoredResourceName"))
	}
	if len(v.ComparisonOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
	}
	if v.Threshold == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Threshold"))
	}
	if v.EvaluationPeriods == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationPeriods"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutInstancePublicPortsInput(v *PutInstancePublicPortsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutInstancePublicPortsInput"}
	if v.PortInfos == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortInfos"))
	}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpRegisterContainerImageInput(v *RegisterContainerImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterContainerImageInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if v.Label == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Label"))
	}
	if v.Digest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Digest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpSetIpAddressTypeInput(v *SetIpAddressTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIpAddressTypeInput"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if len(v.IpAddressType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddressType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetResourceAccessForBucketInput(v *SetResourceAccessForBucketInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetResourceAccessForBucketInput"}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if len(v.Access) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Access"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetupInstanceHttpsInput(v *SetupInstanceHttpsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetupInstanceHttpsInput"}
	if v.InstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceName"))
	}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if v.DomainNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainNames"))
	}
	if len(v.CertificateProvider) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateProvider"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpStopRelationalDatabaseInput(v *StopRelationalDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopRelationalDatabaseInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	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.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestAlarmInput(v *TestAlarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestAlarmInput"}
	if v.AlarmName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlarmName"))
	}
	if len(v.State) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("State"))
	}
	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.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBucketBundleInput(v *UpdateBucketBundleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBucketBundleInput"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBucketInput(v *UpdateBucketInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBucketInput"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.AccessLogConfig != nil {
		if err := validateBucketAccessLogConfig(v.AccessLogConfig); err != nil {
			invalidParams.AddNested("AccessLogConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContainerServiceInput(v *UpdateContainerServiceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContainerServiceInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	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.DistributionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DistributionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDomainEntryInput(v *UpdateDomainEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainEntryInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.DomainEntry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainEntry"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateLoadBalancerAttributeInput(v *UpdateLoadBalancerAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLoadBalancerAttributeInput"}
	if v.LoadBalancerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if len(v.AttributeName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if v.AttributeValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateRelationalDatabaseParametersInput(v *UpdateRelationalDatabaseParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRelationalDatabaseParametersInput"}
	if v.RelationalDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalDatabaseName"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}